Introducing Silico: the platform for building AI models with the precision of written software. Silico lets researchers and engineers see inside their models, debug failures, and intentionally design them from the ground up. Early access is open now. 🧵(1/10)

We’ve used interpretability to discover a novel class of Alzheimer’s biomarkers, teach a language model to correct its own hallucinations, and diagnose performance bottlenecks in a robotics model. Silico brings those frontier techniques to everyone. (2/10)

Silico introduces our model neuroscientist: an autonomous agent that plans and runs concurrent experiments on your model. It works with your team in our model design environment, where you can organize research threads, replicate and extend papers, and collaborate on findings. Here are 5 things you can do with Silico: (3/10)

See inside your model. Decompose your model into interpretable features and tell the difference between real understanding and spurious correlation. (4/10)

Check your model's health. Run comprehensive diagnostics on your model's internal representations to catch issues like undertraining, information bottlenecks, and feature collapse before they impact downstream performance. (5/10)

Debug failures. Precisely debug issues with model behavior, identify and remove confounders, and diagnose failures before they occur in production. (6/10)

Shape model behavior. Use internal features to extract stronger predictors, steer generation, and target generalization that standard training can't reach. (7/10)

Generalize from less data. Target the specific learned structures driving behavior — and shift the training distribution, objective, or architecture to generalize further with the same or less data. (8/10)

MIT Tech Review’s @strwbilly spoke with our CEO/co-founder @eric_ho about Silico and what it means for model builders: (9/10)

Silico is in early access now. Learn more at: (10/10)

can I view exploding gradients with it?

Yes! Model health checks include an entire set of tests that study signal propagation (forward and backward) through the model

👀

Congrats on the launch, super cool product! To shape model behavior does it use steering vectors based on the desired behavior, and how do you ensure it doesn’t degrade the rest of model behavior?

Silico lets you shape model behavior in many ways, including steering vectors, but the biggest successes are generally in shaping the training process itself!

insane

this is sick. autointerp -> autoresearch

@tszzl Finally—treating AI like engineered software instead of alchemy. Transparency, debuggability, and intentional design aren't luxuries, they're the only path to trustworthy systems. Excited for what deliberate intelligence looks like.

@threadreaderapp please #unroll

This looks phenomenal, will check it out this weekend. Is there support for custom architectures that deviate heavily from traditional transformers?

waoh! @karpathy have you tried this?

Vibe Build Models online essentially?

Debug failures from inside the model instead of guessing from outputs. That's the dream for anyone who's spent hours on evals that tell you something's wrong but not why 🎯

The gap Silico is targeting, the ability to see inside a model rather than just observe its outputs, is exactly where the commercial stakes are sharpest in clinical AI. I've been tracking this through Goodfire's trajectory, and what's striking is how fast "interpretability" has moved from a research preference to a procurement requirement. Mayo Clinic taking a financial stake in Goodfire's September 2025 collaboration isn't a goodwill gesture, it's a health system betting that they can't deploy models they can't inspect. The precision-of-written-software framing is interesting because it points at something the safety community has mostly avoided saying plainly: opacity isn't a feature you tolerate, it's a liability you eventually pay for in regulatory friction or clinical failure. And the failure-debugging angle matters more in biology than almost anywhere else. When I looked at what Goodfire actually did with Arc Institute's Evo 2 genomic model, the value wasn't in running the model, it was in decoding what the model had already learned about genomic pathogenicity, knowledge that wasn't in any paper. That's a different use case than most interpretability tooling is built around, less about catching errors and more about extraction. The question for platforms like Silico is whether the architecture supports that direction, not just debugging known failures but surfacing what the model knows that you haven't asked yet. I wrote up the broader investment and regulatory logic behind why this layer is becoming non-optional for health tech at if the Silico team wants the clinical deployment framing alongside the engineering one.

The entre soi of MLOps is real. Another platform promising transparency? Bref. But French startups drowning in notebook spaghetti need actual structure.

I do not want interpretability after the incident report. I want visibility while the system is still live, so debugging a model feels closer to debugging software than reading tea leaves.

can you use silico to learn more about mech interp? a learning mode would be sick!

the bit i keep wondering with tools like Silico: when you find a feature, is it stable across different encoding choices, or an artifact of the SAE you trained? engrams hit the same wall, what you tag at encoding determines what cell-set you can re-fire.

@_virgil19 We use a broad set of tools, much more than SAEs! It's true that standard SAE features can be inconsistent across runs (though check out Archetypal SAEs). Silico is equipped with many different tools, and knows how to use them with the appropriate nuance

appreciate the archetypal SAE pointer. the bit i'm curious about: when silico picks tools mid-investigation, learned selection or hardcoded? curious where 'interp agent' actually diverges from 'scripted pipeline'.

@_virgil19 @GoodfireAI Nothing is hardcoded, the agent picks the right tool for the right job

@GoodfireAI i keep going back to that layer: 'picks the right tool' is where learned vs hardcoded actually matters. is the picker learned end-to-end, or is it a router scaffold the agent fills in?

The mechanistic interpretability research finally becoming a usable engineering tool is what makes this exciting 🙌