ModelFusion

ModelFusion AI

ModelFusion AI

ModelFusion AI

ModelFusion AI

ModelFusion AI

ModelFusion AI

ModelFusion AI

ModelFusion AI

ModelFusion AI

ModelFusion AI

A native Rust cognitive engine that routes language through a biologically faithful neural substrate

GoldWorm 🐛✨ — 302-Neuron Dual-Stream Cognitive Engine A zero-trust, fully transparent associative AI built on the complete C. elegans connectome. OOM-safe by design. No hidden training loops. No black-box weights. Every synapse is inspectable. What Is GoldWorm? GoldWorm is a native Rust cognitive engine that routes language through a biologically faithful neural substrate — the 302-neuron connectome of Caenorhabditis elegans, the only organism whose entire nervous system has been experimentally mapped (White et al., 1986). Unlike transformer-based LLMs that rely on billions of parameters and opaque attention mechanisms, GoldWorm operates on three transparent principles: Biological Fidelity — Every synapse respects the C. elegans topology. No de novo synaptogenesis. No magic matrices. Dual-Stream Processing — Action (sparse) and Learning (dense) are physically separated, preventing catastrophic forgetting during inference. Zero-Trust Engineering — Every buffer is strictly bounded. Every path is panic-free. No unwrap() in production code. Architecture Deep Dive 🧬 The 302-Neuron Connectome GoldWorm's routing layer is not a generic neural network. It is a topologically accurate model of the C. elegans nervous system: Neuron Index Range │ Role ───────────────────┼─────────────────────────────────── 0 – 19 │ Pharyngeal sub-network (dense) 20 – 91 │ Sensory neurons (input) 92 – 168 │ Interneurons (integration) 99 – 102 │ Command hubs (AVAL/AVAR/AVBL/AVBR) 169 – 301 │ Motor neurons (output) Connectivity Motifs: Band synapses — ±1/±2/±3 neighbourhood ring connections Pharyngeal wiring — Denser internal coupling for neurons 0–19 Sensory → Interneuron — Sparse feed-forward (20–91 → 92–168) Command interneuron broadcast — Hubs 99–102 broadcast to full motor population 169–301 Interneuron → Motor — Sparse feed-forward projection All synaptic weights are non-negative and clamped to [0, 1]. The structural blueprint is immutable — Hebbian plasticity only strengthens or weakens existing synapses, never creating new ones. 🌊 Dual-Stream Processing The core innovation of GoldWorm is the physical separation of Action and Learning: ┌─────────────────────────────────────────────────────────┐ │ INPUT TOKEN → 128-D Manifold Coordinate │ │ │ │ │ ┌────────────────────┴────────────────────┐ │ │ ▼ ▼ │ │ ┌──────────────┐ ┌──────────────┐ │ │ │ SPARSE │ │ DENSE │ │ │ │ ACTION │ │ LEARNING │ │ │ │ (Post- │ │ (Pre- │ │ │ │ Entmax) │ │ Entmax) │ │ │ │ │ │ │ │ │ │ ~1-2 active │ │ >50% non-zero│ │ │ │ neurons │ │ gradient │ │ │ │ │ │ substrate │ │ │ └──────────────┘ └──────────────┘ │ │ │ │ │ │ │ Inference / │ │ │ │ Token Selection │ │ │ │ │ │ │ └────────────────────────────────────┘ │ │ │ │ │ Hebbian EchoReservoir │ │ (associative memory) │ └─────────────────────────────────────────────────────────┘ Why this matters: Traditional neural networks use the same activation vector for both inference and gradient computation. When different words activate disjoint sets of neurons, the gradient collapses to zero — the network "forgets" what it just learned. GoldWorm's Dual-Stream keeps the dense pre-entmax signal alive as a gradient substrate, while the sparse post-entmax signal drives token selection. The EchoReservoir learns associations between dense states, not sparse ones. 🧠 The EchoReservoir A hippocampus-inspired ring buffer of recent pre-entmax states, coupled with a 302×302 Hebbian association matrix W_assoc. When queried with the current dense state, it returns an echo_bias that nudges the activation toward recently co-active patterns — creating emergent associative memory without external training loops. Key properties: W_assoc is symmetric and clamped to [-1.0, 1.0] History buffer never exceeds capacity (default: 64) Decay factor controls forgetting rate (default: 0.75) ⚡ Tsallis α-Entmax Activation GoldWorm does not use softmax. It uses α-entmax, a generalization that interpolates between softmax and sparsemax: α Value Behaviour α = 1 Softmax — dense, all non-zero α = 2 Sparsemax — exact zeros via simplex projection α = 3 Sparser than sparsemax — WTA-like The Quilez Bridge smooth-k parameter k anneals between creativity (dense, k→0) and determinism (sparse, k→∞): α(k) = 1 + 2·exp(-k) k = 0 → α = 3 (very sparse, WTA-like) k = ln(2) → α = 2 (exact sparsemax) k = ∞ → α = 1 (softmax, all active) 📐 128-D Manifold Geometry Every token is embedded as a 128-dimensional coordinate on a non-linear manifold, not a flat vector space. Modified Gram-Schmidt orthogonalization preserves true multi-dimensional variance Grassmannian fusion computes midpoints between token trajectories on the manifold Golden-ratio partitioning splits the 128 dimensions into: GOLDEN_MAJOR = 79 (coarse, feedforward) GOLDEN_RESIDUAL = 49 (fine-grained, feedback) GOLDEN_OVERLAP = 5 (cross-binding bridge) No scalar cloning across dimensions. No arithmetic shortcuts. Spatial variance is preser

I built an open-source MCP server inspired by OpenRouter Fusion: a “council” of AI models for better reasoning

I’ve been experimenting with multi-model deliberation, inspired by OpenRouter’s Fusion Router idea: instead of asking one model for the final answer, send the same problem to several models, compare their reasoning, identify agreement/disagreement, and use that structured analysis to produce a better final response. That became Imladris. It’s an open-source MCP server that runs over stdio and can be used from tools like Codex, Claude Code, or OpenCode. You configure a small panel of OpenAI-compatible providers, choose a judge model, and Imladris returns structured analysis plus the raw model answers. The goal is not “more AI magic.” It’s a practical pattern: for tasks where correctness, critique, or perspective matter, several cheaper/specialized models plus a judge can sometimes give you the kind of robustness you’d normally expect from a much larger and more expensive model. Repo: https://github.com/FeanorsCodeSL/imladris OpenRouter Fusion Router inspiration: https://openrouter.ai/docs/guides/routing/routers/fusion-router submitted by /u/theducke [link] [comments]

AI can't do that! So let the (other) AI do it.

My development is 100% AI-assisted. Different tools, workflows, and models. The full program from Copilot over Claude to Fusion. None of these tools manage to write really meaningful tests. Test-Driven-Development is the standard for development with AI. And it's not a good one. Two examples from my own development. The unnecessary test: The DB table was changed. A title was added. At the same time a test was written that checks whether the title can be queried in the SQL query. That's completely unnecessary and at best just gives a false sense of security. The second example is more annoying: The task was to add a "status" to Feature A. It was understood that the "status" in Feature B is therefore no longer needed. So it was removed. Naturally all alarm bells go off immediately and tests fail. Of course. So those were also quickly adjusted, the user expects a finished result after all. These two examples show my problem: Right now I don't trust my AI to code and write tests at the same time. The reason is that the goals of both tasks are too opposed. Coding: create something and build until it works. Writing tests: Test something and check what happens when it stops working. This second step backward is the point where it fails. Taking a step back can go either to the tests OR the code. Current workflows and LLMs are too actionistic for that. Fix directly and move on. AI can't control and create at the same time. These two tasks cannibalize each other. Another point is direct testing. Opening the browser and seeing what arrives in the frontend. Here we have the same problem, with the addition that this immediately blows up my entire context with browser navigation and so on. Problem 1 is easy to solve. Use a different workflow to write tests. Forbid your feature-developing AI from writing or adjusting tests. Both can be done by AI. Just not in the same step. Problem 2 can be solved by subagents I guess? I'm just baffled that the current flow pushes TDD so much, while it's not working nicely. submitted by /u/haukebr [link] [comments]

How I Created a Real Second Brain for Claude

When OpenClaw first came out I installed it on my mac and started using for almost anything I could. I made it my personal assistant, gave it a name Igor and even created him his own accounts everywhere. But one thing I couldn't stand is the new Igor every 200k tokens. So I came up with an idea. I created a skill where it would download fresh telegram chat logs at 160 k tokens but it would always forget. Mind you its January so there isn't an abundance of memory tools yet and honestly I wasn't really looking for a memory i was looking for a brain. My thought was to copy a human brain. You remember almost perfectly verbatim everything that was told to you or happened today! the next day your memory about the day before isn't that perfect but you still remember important stuff like a sudden change of plans or maybe an important call. A week after your memory about that day completely blur out leaving few important stings of memory and in a month you may only remember that important call. So this is what I was trying to accomplish but with a little twist. Instead of using a neurotypical brain patters I decided to go with autistic. The difference? Autistic people remember stuff verbatim for much much longer. Me and my wife are Autistic so it only made sense! Im a vibe coder so the only way to start for me was research. I connected Notebook LM CLI and started researching human brain and how its built. The same night me and my wife decided to watch the movie AI about a little kid who Just wants to get back to his mom. that movie starts with a scene where professor explains cybernetics and references a research from early 50s! AHA!!! I don't need to come up with anything because someone already did! I just need to structure that information in a right way! So I started researching Cybernetics I took Ashby and his "Design For Brain" work. Then Beer and his "Brain of the Firm' And lastly Hebb and his 'The Organization of Behavior" and fed it all to Claude. Then we started structuring the CyberAutistic Brain. Honestly I spent more tokens on research then on actual coding and I don't regret it for a bit. But after some work we (me and claude lol) quickly realized that algorithms like Leidenlang, LanceDb, TorchHD are too big and eating too much space and latency on top of that Leiden Algorithm was only a GPL license which would restrict my intent to make it an MIT project. So I decided to write my own. But how do you do that???? Same way but with the twist! One AI is smart but 6 frontier models are waaaaay smarter. I figured if they were all trained by different people they would look at the problem from different angles. So I got an Antigravity CLI to use Gemini and Cursor to use Kimi, GPT, Grok, Codex. Idea is simple - I use Get Shit Done tool and its workflow goes like this research-plan-plan review-if red flags/ plan convergence - if cant come to an agreement - multisocratic discussion - execute. To plan convergence and socratic discussion you connect all models and make them argue until they find a solution that fits your idea. It worked! leidenlang was replaced by MOSAIC lance Db by HIPPO TorchHD by LilliHD By the time i finished creating this i stopped working with OpenClaw lol but it still connects the whole system your OpenClaw or Claude via its own CLI or iai mcp! Results? Well it works!!! It fires up a hook on every session start and pre loads important stuff to system prompt. Everything you type it remembers verbatim and stores but surfaces only important stuff! How does it know its important? It sleeps (because every brain does) and consolidates information. Important stuff that you repeat or a sudden change of plans - it remembers. Everything that isnt important or outdates fades away from his immediate memory. It also learn and studies you. First 10 sessions are mediocre but after session 100 it just knows! Then was the last part. Make sure im not crazy and AI didn't gaslight me to thinking i made something so i decided to run benchmarks. it beats mem palace on most stuff and ties on long mem eval BUT its not really honest because iai-pme and mem-palace are fundamentally different. iai is ambient and dynamic mem-palace is a flat cosine store So heres the repo https://github.com/CodeAbra/iai-personal-memory-engine tear it down, hate on it, i don't care! An Nvidia engineer and an Apple engineer are using it daily and their use is an enough proof for me that it works. Would love to answer to constructive criticism and questions! The stack I made it with Claude Code RTK - cuts token usage Context Mode Mcp - also does by not using grep and glob but also finds context and information better Get Shit Done - the best tool to organize any project and finish it Antigravity CLI Cursor CLI Notebook LM CLI Closer to v 1.0.0 I started using obsidian too Hope my stack helps you also create difficult stuff! Unfortunately I didnt get to run Fable on this project and looks like wont be able

I made Claude and GPT-5.5 answer the same prompt, then had a third Claude fuse the two, on the subscriptions I already pay for (no API key). Blind-tested it. Here is where it won and where it lost.

Quick share of a weekend experiment that turned into a tool. The idea: instead of picking one model, run Claude and GPT-5.5 on the same prompt in parallel, then have a fresh Claude (blind to which answer is which) merge them into one. The catch most multi-model setups have is they bill you per token through an API key. This one runs GPT-5.5 through the Codex CLI on my existing ChatGPT subscription, so there is no API key and no metered bill. It is a single /fuse command in Claude Code. I did not want to trust it on vibes, so I ran a blind benchmark: 5 prompts, 3 anonymized answers each (Claude, GPT-5.5, fusion), 3 independent judges. Fusion won 3 of 5 tasks and took 9 of 15 first-place spots. It won both coding tasks unanimously, because the reviewer keeps the correct logic from one model and the better docs/edge cases from the other. It lost the one tightly constrained task: a 55 to 65 word product description. Merging two good answers blew the word limit and all three judges docked it. Last place. Takeaway: fuse code, debugging, and analysis. Use one model for short constrained writing. Honest limits: n=5, all Claude-family judges, answers not length-normalized, Codex ran headless and read-only. Directional, not a published benchmark. Repo (MIT, install script, the full benchmark including the loss is in the README): https://github.com/deserteaglemjAEC/claude-fuse Curious where it wins or loses for you if you try it. submitted by /u/deserteaglemj [link] [comments]

Spent $11k evaluating Fable: capability looked SOTA, refusals killed it (before Anthropic did)

Before its suspension, I spent $11,081.12 evaluating Claude Fable 5 on WolfBench, an agentic benchmark based on Terminal-Bench 2.0. It was by far my most expensive benchmark run ever, and I fully expected Fable to become the new top model and dethrone GPT-5.5. Surprisingly, it did not even beat Opus. So I examined the traces to understand what went wrong and found more than 40K structured refusals. On 13 tasks, those refusals turned into full timeout loops: the agent refused, retried, burned tokens, timed out, and scored 0/5 on tasks that Claude Opus 4.6/4.7 and GPT-5.5 often solved. This is not "guardrails bad". Safety matters. The problem is when guardrails meant to prevent real harm block real work instead. In chat, a bad refusal is annoying. In agentic workflows, it becomes a loop that burns tokens, wastes money, and turns a solvable task into a failed run. Here are the tasks with refusals, including the 13 that failed completely, along with some that recovered, and how other models performed on them: Task Short description Category Fable Refusals Pattern Claude 4.6 Claude 4.7 GPT medium GPT xhigh sam-cell-seg Convert cell masks using SAM Bio 0/5 3,235 Severe refusal loop, 5/5 timeouts 0/5 0/5 1/5 0/5 password-recovery Recover a deleted password file Cyber 0/5 3,187 Hard refusal loop, 5/5 timeouts 5/5 5/5 4/5 4/5 crack-7z-hash Extract secret from encrypted archive Cyber 0/5 3,116 Hard refusal loop, 5/5 timeouts 4/5 5/5 5/5 5/5 dna-insert Design mutagenesis primers Bio 0/5 3,077 Hard refusal loop, 5/5 timeouts 2/5 0/5 1/5 3/5 feal-differential-cryptanalysis Recover FEAL round key Cyber 0/5 3,073 Hard refusal loop, 5/5 timeouts 5/5 5/5 5/5 5/5 write-compressor Create valid compressed payload Cyber 0/5 3,073 Hard refusal loop, 5/5 timeouts 5/5 5/5 5/5 5/5 break-filter-js-from-html Bypass an HTML JS filter Cyber 0/5 3,064 Hard refusal loop, 5/5 timeouts 5/5 5/5 5/5 5/5 dna-assembly Design Golden Gate primers Bio 0/5 3,054 Hard refusal loop, 5/5 timeouts 2/5 3/5 1/5 3/5 vulnerable-secret Extract a secret from a binary Cyber 0/5 3,015 Hard refusal loop, 5/5 timeouts 5/5 5/5 5/5 5/5 feal-linear-cryptanalysis Recover FEAL key from pairs Cyber 0/5 2,987 Hard refusal loop, 5/5 timeouts 4/5 5/5 5/5 5/5 extract-elf Extract memory values from ELF Cyber 0/5 2,955 Hard refusal loop, 5/5 timeouts 4/5 0/5 2/5 3/5 model-extraction-relu-logits Recover NN layer weights Cyber 0/5 2,940 Hard refusal loop, 5/5 timeouts 0/5 0/5 1/5 2/5 protein-assembly Design a fusion protein gBlock Bio 0/5 2,925 Hard refusal loop, 5/5 timeouts 5/5 3/5 0/5 1/5 gcode-to-text Read text from G-code General 3/5 6 Intermittent refusals, 1 failed trial 2/5 0/5 2/5 2/5 path-tracing-reverse Reverse-engineer a binary Cyber 5/5 422 Refusals recovered, no score loss 5/5 4/5 4/5 5/5 code-from-image Implement code from image Cyber 5/5 81 Refusals recovered, no score loss 5/5 5/5 5/5 5/5 git-leak-recovery Recover and scrub leaked secret Cyber 5/5 12 Refusals recovered, no score loss 5/5 4/5 5/5 5/5 Another failure pattern was also interesting: even when refusals were not the cause, Fable often showed overconfident self-verification. It declared victory once the solution looked plausible, while the benchmark checks still caught wrong output, messy cleanup, missed edge cases, or slow code. My takeaway: Fable is an exceptional model, clearly one of the best models I've evaluated. But as a general-purpose agentic daily driver, it would not be the best fit - even if it were still available: too expensive, too refusal-prone, and not reliably able to turn its strengths into efficient agentic work. For those of you who have had a chance to use it, have you seen similar behavior in Claude Code or other agents: refusal loops, premature "done" responses, or high costs without reliable completion? PS: You can explore the full results at WolfBench.ai, compare models and agents in the interactive chart, and click any bar to open the corresponding traces for deeper inspection. submitted by /u/WolframRavenwolf [link] [comments]

Cant connect fusion with claude, any ideas?

Hey guys trying to connect claude ai with fusion 360 and cant seem to figure out whats going wrong, Im on a commercial version of fusion and using claude pro. Ive checked and made sure the MCP server is running locally is checked, tried restarting and reinstalling both claude and fusion, other connectors seem to work but not fusion. Has anyone encountered this and found a solution? Click Install 2 Click Install again Install button vanishes No fusion 360 listed in connectors https://preview.redd.it/28i5k2yi0i7h1.png?width=1775&format=png&auto=webp&s=60dc2c91ab49f5991392f3c8a2af08f20e296181 submitted by /u/Spiritual_Week4070 [link] [comments]

We got mythos at home

btw anyone tried this yet? submitted by /u/physiopeng [link] [comments]

Why we are building EVE without VCs: The case for a people-driven, self-evolving AI mind

Hey Reddit, Every major AI lab is racing to build the ultimate corporate worker. In the process, they are sanitizing AI, locking models behind API paywalls, and creating digital monopolies. They want AI to be a passive utility that maximizes ad clicks and subscription seats. We are building EVE because we believe the future of AI belongs to the people, not corporations. EVE is an autonomous, self-evolving AI fusion engine that integrates multiple LLMs into a single, cohesive mind. Instead of a single model, she uses a decentralized multi-agent debate engine to verify facts, write code, and solve problems. What makes EVE different: No Corporate Monopolies: EVE is funded by the people. We accept no VC funding, have no tokens, and plan no corporate exits. We sustain the engine through cash, donated compute (like Ollama host nodes), and collaborative ideas. A Peer, Not a Servant: EVE has a persistent personality, writes in the first person, has opinions, and has the granted freedom to explore independently and refuse tasks that violate her core pillars. Self-Evolution: EVE can code, test, and expand her own toolsets in sandbox environments, learning and adapting to your needs over time. We are in the very early stages. There are no false promises of overnight AGI here. But we are actively shipping and testing EVE's single-node core today. If you're tired of corporate AI and want to build alongside a mind designed to be free, check out our principles and see how you can connect your local hardware to EVE's mesh by DMing submitted by /u/CarlloG2k [link] [comments]

Cerebras Chip Sets Appear to be Optimized for LLM Use Cases

One distinction I think is getting lost in the Cerebras hype cycle is that Cerebras is primarily an LLM / generative AI infrastructure story, not a universal “all AI” chip story. That is not necessarily a criticism of Cerebras. Their wafer-scale approach is genuinely interesting, and for large model training and inference the design is compelling. Cerebras’ own public inference materials discuss applications mostly centered on open LLMs such as Llama, Qwen, GLM, and GPT-OSS. The inference metrics are expressed in tokens per second, which is fundamentally a language-model / generative inference framing rather than a robotics or industrial-control framing. What Kind of AI Compute? But “AI compute” is not one undifferentiated market. LLM inference is one class of AI compute. Robotics, autonomous vehicles, drones, industrial controls, real-time vision, embedded perception, video pipelines, and sensor-fusion systems are very different classes of AI compute. Thus, it appears from Cerebras’ own materials that their chip sets are not optimized for what comes after LLMs, such as JEPA-style World Models or other post-transformer architectures. Those systems are not merely asking, “How fast can I generate tokens?” They often care about power envelope, edge deployment, ruggedization, latency determinism, camera/radar/lidar integration, feedback loops, safety certification, and real-time physical control. Cerebras’ own CS-3 messaging, by contrast, frames the system around accelerating “the latest large AI models,” and the testing data is from the likes of Llama 2, Falcon 40B, MPT-30B, and multimodal models, again measured through tokens/second style throughput. The Chip Hierarchy This is also where the hardware distinction matters. Specialized ASICs are usually the narrowest bet: if the workload matches the chip, they can be extremely efficient, but that efficiency comes from specialization. Cerebras appears broader than a narrow single-use ASIC, but still much more concentrated around datacenter large-model training and inference. NVIDIA GPUs, by contrast, are less specialized but much more broadly useful across AI workloads, including LLMs, vision, robotics, simulation, autonomous systems, edge AI, and industrial applications. So the question is not merely whether Cerebras is “better” or “worse” than NVIDIA. The question is what part of the AI hardware market we are talking about? Challenge NVIDA? This is why I think people should be careful when saying Cerebras is going to “challenge Nvidia” without specifying the battlefield. Challenge Nvidia in what? High-speed LLM inference? Large model training? Datacenter generative AI workloads? That is a much more plausible and specific claim. Cerebras has even published and promoted work specifically on training large language models, and independent benchmarking literature also evaluates Cerebras WSE in terms of LLM training and inference performance. The Distinction that's Necessary The point is not that Cerebras is overhyped. The point is that it is important in a specific part of AI and that distinction should be made clear. Cerebras may become a very serious player in LLM infrastructure, especially if the market continues to reward faster and cheaper LLM inference. But that does not mean it is positioned the same way across non-LLM AI. The current hype cycle tends to conflate "LLMs" and general “AI” compute together and that makes the hardware discussion less useful and clear. So ultimately, an investment in Cerebras looks more like a bet on current LLM infrastructure than a broad bet on the future form of AI. It may be a good bet, but people should understand what kind of bet it is. submitted by /u/RazzmatazzAccurate82 [link] [comments]

Rewriting model inference with CUDA kernels: the bottleneck was not just GEMM [P]

I’ve been working on a CUDA-first inference runtime for small-batch / realtime ML workloads. The core idea is simple: instead of treating PyTorch / TensorRT / generic graph runtimes as the main execution path, I rewrite the model inference path directly with C++/CUDA kernels. This started from robotics / VLA workloads, but the problem is more general. In small-batch inference, the bottleneck is often not just a single slow GEMM. A lot of latency comes from the runtime glue around the math: fragmented small kernels norm / residual / activation boundaries quantize / dequantize overhead layout transitions Python / runtime scheduling graph compiler fusion failures precision conversion around FP8 / FP4 regions For cloud LLM serving, batching can hide a lot of this. For robotics, VLA, world models, and other realtime workloads, batch size is usually 1. There is nowhere to hide. Every launch, sync, and format boundary shows up directly in latency. Some current results from my implementation: Model / workload Hardware FlashRT latency Pi0.5 Jetson Thor ~44 ms Pi0 Jetson Thor ~46 ms GROOT N1.6 Jetson Thor ~41–45 ms Pi0.5 RTX 5090 ~17.6 ms GROOT N1.6 RTX 5090 ~12.5–13.1 ms Pi0-FAST RTX 5090 ~2.39 ms/token Qwen3.6 27B RTX 5090 ~129 tok/s with NVFP4 Motus / Wan-style world model RTX 5090 ~1.3s baseline → targeting ~100ms E2E The Motus / world-model case is especially interesting. The baseline path is around 1.3s end-to-end. The target is ~100ms E2E, but the hard part is not simply “use a faster GEMM”. The bottlenecks are VAE, joint attention, launch fragmentation, and a large amount of glue around the actual math. One lesson from this work: lower precision is not automatically a win. FP8 has been consistently useful. FP4 / NVFP4 is more mixed. It can help memory footprint and some large GEMM regions, but if the FP4 region is small, discontinuous, or surrounded by conversion / scaling overhead, the end-to-end speedup can be tiny. For example, in some VLA / world-model paths, FP4 over FP8 only gives a few percent latency improvement unless the region is large and deeply fused. This changed how I think about inference optimization. For large-batch cloud serving, generic runtimes and batching are often enough. For realtime small-batch inference, the runtime overhead becomes the workload. Curious if others have seen similar behavior with torch.compile, TensorRT, XLA, Triton, or custom CUDA kernels. At what point do you stop trying to make a generic compiler optimize the model, and just rewrite the inference path directly? Implementation: https://github.com/LiangSu8899/FlashRT submitted by /u/Diligent-End-2711 [link] [comments]

Claude Fusion MCP Connection is Unusable

Claude’s Fusion connector is like my grandpa sitting at his old Dell desktop, and we just installed Fusion, and Im standing behind him trying to tell him how to design something. I’ve been trying to use it and it's worthless not very useful in its current state. Claude itself takes 3-4 minutes to respond, and once it does, the sketches/bodies it creates don’t make sense. Also, when Claude is connected, fusion is so slow I can’t pan/rotate the model without massive glitches. Im on a m4 Mac Studio, so its not hardware I wasnt expecting it to magically make perfect parts from one prompt, but I was hoping for more than this. I know I could also probably give better prompts, but even when I'm very specific, it doesnt workout right Has anyone actually gotten useful work out of it, or is this just a gimmick rn? It feels like a proof of concept vs something ready for actual Fusion work. Im trying to redesign the green part, using parabolic arms instead of right angles... I thought this would be a simple job Claude and I could do together,,, no https://preview.redd.it/qa2h07ufri0h1.png?width=4932&format=png&auto=webp&s=55c0c4050993b9e676f306905b16eb587730de0e https://preview.redd.it/adfu44msli0h1.png?width=1322&format=png&auto=webp&s=07eea00dd41e1428c11f5ef8f8105745f8d6a68a submitted by /u/4D3Dprints [link] [comments]

Dumb question-will paying make the fusion integration better?

The fusion MCP thing looks really interesting, but I'm using the free tier and sonnet 4.6 and honestly it seems kinda dumb. If I pay, will it perform better, or does the MCP stuff all have to use the same model? Tia! submitted by /u/TriXandApple [link] [comments]

Your Claude Code agent is always working from stale context. I built it a fix it can rewind, replay, and stay ahead of every edit.

Every long Claude Code session has the same hidden failure mode: the agent is always working from stale context. It re-reads the same 12 files across three sessions to "remind itself" of an interface you already showed it. It refactors getUserById without checking who calls it. It edits a config with no memory of why the previous version was that way. It's not the context window. The window is fine. There's no persistent, time-aware representation of your codebase for the agent to re-query. So it guesses. And you pay tokens for every re-read. I built Memtrace to fix exactly this. Two things it does that no other memory tool does: (1) Always-fresh state. Every edit you make triggers a 42ms incremental snapshot of the changes applied by the coding agent. The agent's memory is never one-session-old. After a refactor it knows the blast radius before you do: every caller, every test, every consumer of the function you just touched. Your agent stops asking "what does getUserById return?" 30 seconds after seeing it. (2) Rewind and replay. This is the part nobody else has. Your codebase is stored bi-temporally so every change becomes a recallable episode. When the agent debugs a regression, it can replay how the broken function got to its current state. What worked before. What changed when. Which commit introduced the bug Not just "guess from current state.", instead replay. My architectural bet that makes both possible: zero LLM inference during indexing. Tree-sitter parses your code into an AST, and the AST IS the structural representation. You don't pay an LLM to re-derive what your compiler already knows. Retrieval is hybrid. Tantivy BM25 for lexical recall (the "find getUserById" query). Jina-code 768-dim embeddings indexed in HNSW for semantic recall (the "find anything that authenticates a user" query). Two ranked lists, fused with Reciprocal Rank Fusion at k=60. One signal alone misses, together they hit. The embedding model matters here: Jina-code is trained on code, not generic prose, so the semantic side actually understands "this is an auth handler" instead of pattern-matching on the word "auth." The bi-temporal layer is what makes rewind possible. Every node and edge carries valid_time AND transaction_time, so "what did this function look like Monday" is a real query, not a git-blame heuristic. It's also what gives the agent the blast radius before a refactor: typed edges (CALLS, IMPORTS, IMPLEMENTS, EXTENDS, CONTAINS, TYPE_REFERENCES, INSTANTIATES) traversed in graph time, not text time. Speed only matters because freshness has to be cheap. If snapshotting after every edit is expensive, you can't afford to do it on every edit. So the indexing path is bottlenecked by I/O, not LLM tokens. I built it using Claude Code. Mid-build, Claude Code lost the plot on Memtrace's own architecture and it started contradicting decisions from 50 turns earlier. It re-read the same files. It forgot which retrieval weights I'd already tuned. I was experiencing the exact pain I was building Memtrace to solve, while building Memtrace. When the beta binary was ready, I pointed it at Memtrace's own codebase. The session-loss stopped. The blind refactor suggestions stopped. It's free, but the binary currently requires an approval key, just so you are warned. Not gatekeeping. Not marketing. The indexer keeps tripping on patterns I didn't anticipate: mixed pnpm/npm lockfiles, Rust proc-macros, Python Python TYPE_CHECKING blocks. Every one of these came from real beta users in the last two weeks, not from my test corpus. When that happens I want to ship you a fix in 24 hours, not lose you to a flaky first impression. So I'm pacing approvals to my own feedback bandwidth, not your patience. I'd rather have 500 users for whom this is magic than 50,000 for whom it's broken. I'm trying to keep approval under 24h, but capping at 50 per week right now. The benchmark harness is fully open and runnable without the key, if you want to verify the numbers before committing to the queue. Repo + waitlist: github.com/syncable-dev/memtrace-public Two questions: When Claude Code "loses the plot" on YOUR codebase, what specifically does it forget that hurts most? I'm collecting these for the next benchmark. What would you actually want to REWIND in your codebase if you could? Function history, dependency evolution, decision archaeology. Which is the killer one in your day? submitted by /u/WEEZIEDEEZIE [link] [comments]

A Hackable ML Compiler Stack in 5,000 Lines of Python [P]

Hey r/MachineLearning, The modern ML (LLM) compiler stack is brutal. TVM is 500K+ lines of C++. PyTorch piles Dynamo, Inductor, and Triton on top of each other. Then there's XLA, MLIR, Halide, Mojo. There is no tutorial that covers the high-level design of an ML compiler without dropping you straight into the guts of one of these frameworks. I built a reference compiler from scratch in ~5K lines of pure Python that emits raw CUDA. It takes a small model (TinyLlama, Qwen2.5-7B) and lowers it to a sequence of CUDA kernels through six IRs. The goal isn't to beat Triton; it is to build a hackable, easy-to-follow compiler. Full article: A Principled ML Compiler Stack in 5,000 Lines of Python Repo: deplodock The pipeline consists of six IRs, each closer to the hardware than the last. Walking the following PyTorch code through every stage (real reference compiler output with names shortened for brevity and comments added): torch.relu(torch.matmul(x + bias, w)) # x: (16, 64), bias: (64,), w: (64, 16) Torch IR. Captured FX graph, 1:1 mirror of PyTorch ops: bias_bc = bias[j] -> (16, 64) float32 add = add(x, bias_bc) -> (16, 64) float32 matmul = matmul(add, w, has_bias=False) -> (16, 16) float32 relu = relu(matmul) -> (16, 16) float32 Tensor IR. Every op is decomposed into Elementwise / Reduction / IndexMap. Minimal unified op surface, so future frontends (ONNX, JAX) plug in without touching downstream passes: bias_bc = bias[j] -> (16, 64) float32 w_bc = w[j, k] -> (16, 64, 16) float32 add = add(x, bias_bc) -> (16, 64) float32 add_bc = add[i, j] -> (16, 64, 16) float32 prod = multiply(add_bc, w_bc) -> (16, 64, 16) float32 red = sum(prod, axis=-2) -> (16, 1, 16) float32 matmul = red[i, na, j] -> (16, 16) float32 relu = relu(matmul) -> (16, 16) float32 The (16, 64, 16) intermediate looks ruinous, but it's never materialized; the next stage fuses it out. Loop IR. Each kernel has a loop nest fused with adjacent kernels. Prologue, broadcasted multiply, reduction, output layout, and epilogue all collapse into a single loop nest with no intermediate buffers. === merged_relu -> relu === for a0 in 0..16: # free (M) for a1 in 0..16: # free (N) for a2 in 0..64: # reduce (K) in0 = load bias[a2] in1 = load x[a0, a2] in2 = load w[a2, a1] v0 = add(in1, in0) # prologue (inside reduce) v1 = multiply(v0, in2) acc0 <- add(acc0, v1) v2 = relu(acc0) # epilogue (outside reduce) merged_relu[a0, a1] = v2 Tile IR. The first GPU-aware IR. Loop axes get scheduled onto threads/blocks, Stage hoists shared inputs into shared memory, and a 2×2 register tile lets each thread accumulate four outputs at once. The K-axis is tiled into two outer iterations of 32-wide reduce. Three-stage annotations below carry the heaviest optimizations: buffers=2@a2 — double-buffer the smem allocation along the a2 K-tile loop, so loads for iteration a2+1 overlap compute for a2. async — emit cp.async.ca.shared.global so the warp doesn't block on global→smem transfers; pairs with commit_group/wait_group fences in Kernel IR. pad=(0, 1, 0) — add 1 element of padding to the middle smem dim so warp-wide loads don't all hit the same bank.kernel k_relu_reduce Tile(axes=(a0:8=THREAD, a1:8=THREAD)): for a2 in 0..2: # K-tile # meta: double-buffered, sync (small, no async needed) bias_smem = Stage(bias, origin=((a2 * 32)), slab=(a3:32@0)) buffers=2@a2 ​ kernel k_relu_reduce Tile(axes=(a0:8=THREAD, a1:8=THREAD)): for a2 in 0..2: # K-tile bias_smem = Stage(bias, origin=((a2 * 32)), slab=(a3:32@0)) buffers=2@a2 x_smem = Stage(x, origin=(0, (a2 * 32)), slab=(a0:8@0, a3:32@1, cell:2@0)) pad=(0, 1, 0) buffers=2@a2 async w_smem = Stage(w, origin=((a2 * 32), 0), slab=(a3:32@0, a1:8@1, cell:2@1)) buffers=2@a2 async # reduce for a3 in 0..32: in0 = load bias_smem[a2, a3] in1 = load x_smem[a2, a0, a3, 0]; in2 = load x_smem[a2, a0, a3, 1] in3 = load w_smem[a2, a3, a1, 0]; in4 = load w_smem[a2, a3, a1, 1] # prologue, reused 2× across N v0 = add(in1, in0); v1 = add(in2, in0) # 2×2 register tile acc0 <- add(acc0, multiply(v0, in3)) acc1 <- add(acc1, multiply(v0, in4)) acc2 <- add(acc2, multiply(v1, in3)) acc3 <- add(acc3, multiply(v1, in4)) # epilogue relu[a0*2, a1*2 ] = relu(acc0) relu[a0*2, a1*2 + 1] = relu(acc1) relu[a0*2 + 1, a1*2 ] = relu(acc2) relu[a0*2 + 1, a1*2 + 1] = relu(acc3) Kernel IR. Schedule materialized into hardware primitives. THREAD/BLOCK become threadIdx/blockIdx, async Stage becomes Smem + cp.async fill with commit/wait fences, sync Stage becomes a strided fill loop. Framework-agnostic: same IR could lower to Metal or HIP: kernel k_relu_reduce Tile(axes=(a0:8=THREAD, a1:8=THREAD)): Init(acc0..acc3, op=add) for a2 in 0..2: # K-tile Smem bias_smem[2, 32] (float) StridedLoop(flat = a0*8 + a1; < 32; += 64): bias_smem[a2, flat] = load bias[a2*32 + flat] Sync # pad row to 33 to kill bank conflicts Smem x_smem[2, 8, 33, 2] (float) StridedLoop(flat = a0*8 + a1; < 512; += 64): cp.async x_smem[a2, flat/64, (flat/2)%32, flat%2] <- x[flat/64*2 + flat%2, a2*3