Etch Labs is an AI lab, but not the kind you're used to reading about. We don't train frontier models. We don't publish scaling laws. We ship small, reproducible agents that do one job well, are practically free to run, with AI that can be audited and traced line by line by anyone who asks.
The reason this works, and the reason it's worth building, is that the hard part of an agent was never the reasoning. It was the interface.
The interface was the unlock. Not the model.
Think about what actually changed between 2022 and 2024. The technical leap everyone remembers is the model getting bigger. The leap that changed how people use AI was something quieter: we collectively learned how to present reasoning as a live, legible stream. Tool calls. Intermediate observations. Natural-language thoughts between actions. The <think> block.
That interface is genuinely excellent. It turns a black box into something you can read over the shoulder of. It lets a non-engineer follow an agent's logic and decide whether to trust the output. It's the single most important usability advance in the last decade of applied AI.
It is also (and this is the part almost nobody says out loud) completely decoupled from the model underneath.
The reasoning stream isn't evidence of emergent intelligence. It's a rendering layer. Give it a programmatic, deterministic engine underneath and the user experience is indistinguishable from an LLM agent. The tool calls happen. The intermediate text flows. The report arrives. What changes is that the agent is now 10-100x faster, orders of magnitude cheaper, and structurally incapable of hallucinating.
We've done this before.
IBM Watson won Jeopardy in 2011 without a trained neural network at all. It was a pipeline: information retrieval, NLP, statistical scoring across candidate answers. The public and the press accepted it as AI. The field accepted it as AI. The label followed capability, not architecture.
Expert systems, rule engines, decision pipelines, constraint solvers. These were the bulk of applied AI for thirty years. They didn't disappear because they stopped working. They receded from the narrative because something louder arrived. But the technique remained valid the entire time, waiting for the right packaging.
That packaging is here now. The 2024-era agent stack, including streaming reasoning, tool protocols, structured outputs, is the missing UX layer that rule-based AI never got to wear. Put it on, and a carefully specified pipeline looks and feels like a frontier agent, without any of the cost, latency, or risk of hallucination.
Use deterministic agents in production.
Determinism is not a philosophical preference. It's an economic one.
Token costs for LLMs are rising dramatically, and every extra second spent waiting for a response is money burnt: not just compute, but lost opportunity and team efficiency. Every API call, every minute waiting for a response, adds up fast. For production workloads and at scale, your company is paying real dollars just waiting for a model to finish thinking.
With expert systems, those costs collapse to near zero. Outputs are delivered almost instantly, regardless of load or complexity. There’s no high marginal cost per call, no unpredictable spikes, no need to optimize for tokens burned. The outcome is the same every time: fast, reliable, and most importantly, practically free to run.
Time is money. With deterministic, rule-based agents, you stop wasting it. The cost of decision-making drops out of the equation, and your team (or your customer’s agent) gets what it needs instantly, at scale, without breaking the budget.
What Etch Labs is doing.
We open-source our agents and ship an SDK so you can build your own. Agents are readable, forkable, and annotatable. The reasoning isn't locked in a service, it lives in code you can inspect and extend.
The SDK is the core of what we offer. It handles the scaffolding that makes deterministic agents feel like modern ones: structured tool dispatch, streaming reasoning output, typed inputs and outputs, and reproducible traces you can diff across runs. You bring the domain logic; the SDK handles everything else.
Most production agents should be built in two layers. A small language model (or a thin rules layer) handles intent and narrative: routing the request, choosing which expert to call, and turning structured results into something a human can act on. Deterministic experts handle anything that touches money, inventory, or compliance: the fetches, comparisons, scoring, and reports grounded in your systems. The LLM is the editor; the expert is the engine. Etch Labs builds the engine and the streaming shell.
A large fraction of real-world AI work sits in this shape. Compliance checks. Fraud pattern detection. Reporting. Structured data extraction. Risk scoring. Triage against explicit criteria. Anywhere the logic is specifiable, the SDK gives you a faster, cheaper, and more auditable path than reaching for a deterministic model.
What we're not.
We aren't against frontier models. LLMs are the right call for genuinely open-ended tasks, for problems where creative judgment outperforms explicit rules, for inputs too irregular to enumerate. That's a real category of work. It just isn't all of it, and it isn't most of the work that gets called "AI agents" in production today.
We also aren't a throwback. The techniques are old. The packaging is not. What we're doing is only possible because of everything the field has learned in the last few years about how to make reasoning legible. We stand on that, and we're grateful for it.
A closing thought.
Everything on this site runs live. Determinism works. For certain problems, it is the faster, cheaper, and more auditable option.
If any of this rhymes with how you think about the next decade of software, we'd like to hear from you.
— Andrew Campi
Founder, Etch Labs