TypeScript Agent Framework Runs AI Code in a Sandbox
AI agent demos are easy—production systems aren't. Nous is a TypeScript framework solving this with sandbox execution, tracing, and persistence.
A new open-source project called Nous just landed on Hacker News, and it is worth a few minutes of attention from any team weighing whether to build AI agents in-house. It is an agent framework aimed squarely at developers who work in TypeScript, and it tackles a problem most teams hit within their first week of agent experiments: the gap between a flashy demo and something you can actually run, trace, and trust in production.
We build products for a living, so we read these releases through one lens: what does it cost a team to get from idea to working system, and what does this tool change about that math? Here is our read.
The problem: agent demos are cheap, agent infrastructure is not
Spinning up a single LLM call that "acts like an agent" takes an afternoon. Turning that into something a business can rely on takes months, because the demo is the easy 20%. The hard 80% is everything around it: persisting agent runs to a database, tracing what the model actually did when it goes wrong, keeping a human in the loop for risky actions, and wiring up tools without rewriting glue code every time you add one.
This is the same pattern we see across the stack. A CMS is not valuable because it stores text — it is valuable because it ships with the boring 80% (auth, media handling, roles, drafts) already built, like a furnished apartment versus a pile of lumber. An agent framework earns its keep the same way. The question is never "can it call an LLM?" It is "how much of the unglamorous plumbing do I get for free?"
Nous is interesting because its author, the DevOps/SRE lead at an AdTech company, built it from the plumbing inward over five to six months. It did not start as a framework. It started as an attempt to automate a single Jira ticket — adding an index to a Google Spanner database — and grew outward from that real chore. That origin matters, and we will come back to why.
What Nous actually is
The author describes it as "a bit of CrewAI, OpenDevin, and LangFuse/Cloud all in one." Translated into plain terms, that means it bundles three things teams usually have to assemble themselves:
- Multi-agent orchestration (the CrewAI part) — agents that can coordinate and hand off work.
- A software-engineering agent (the OpenDevin part) — an agent that reads and writes code.
- Tracing and observability (the LangFuse part) — a record of what every agent did, so failures are debuggable instead of mysterious.
On top of that it adds database persistence, a Web UI, and human-in-the-loop approval. The coding agent is built as a layer above Aider, a well-regarded open-source pair-programming tool, rather than reinventing code editing from scratch. That is a sensible engineering decision: stand on a proven tool, add value above it.
The project's stated motivation is also telling. The author started after repeatedly opening the LangChain docs and "never liking the example code." LangChain is the default name in this space, and "the abstractions felt heavier than the problem" is one of the most common complaints we hear from engineering teams who try it. A TypeScript-native alternative with cleaner ergonomics fills a real gap — most serious agent tooling has been Python-first, which leaves a lot of product teams writing throwaway Python services just to run agents next to their TypeScript codebase.
Built from a real chore, not a pitch deck
The detail we keep returning to is that origin story: a DevOps lead automating his own Jira backlog. The included tooling reflects it — most notably a configurable GitLab merge-request AI reviewer, the kind of thing an SRE team actually wants on day one.
Honest take: tools built to scratch a real internal itch tend to age better than tools built to win a launch. The author already used this on database indexing requests and code review before publishing it. That is the opposite of a weekend demo, and it shows in the feature list.
The interesting bit: agents that write code instead of taking turns
The standout feature is the new autonomous agent, and it is worth understanding because it changes the cost equation.
Most agent frameworks work in a turn-by-turn loop. The model says "call tool A," the system runs it, sends the result back, the model says "now call tool B," and so on. Each step is a separate round-trip to the LLM. If a task needs ten tool calls, that is roughly ten model invocations — ten chances to pay for tokens, ten chances to wait on latency, and ten chances for the model to lose the thread.
Nous takes a different route. Its autonomous agent generates Python code that calls the available functions directly. Using the Pyodide library, the framework proxies the tool objects into a Python scope and runs that code inside a WebAssembly sandbox. Because the agent can make multiple calls and run its own validation logic inside a single control loop, it collapses what would have been many model round-trips into one.
Put simply: instead of asking the model to do arithmetic out loud, one digit at a time, you hand it a calculator and let it run the whole calculation in one pass. The author's claim is that this reduces cost and latency while getting better reasoning out of frontier models — and the mechanism behind that claim is sound. This is the same idea behind the "code as action" research direction the broader field has been moving toward: letting models express plans as executable code is often more reliable and cheaper than narrating tool calls one at a time.
Why a WebAssembly sandbox matters for business
Letting an LLM write and execute code is powerful and obviously a little terrifying. The WebAssembly sandbox is the safety answer, and it is the part a CTO should care about most.
A WebAssembly sandbox is a sealed test kitchen. The agent can cook freely inside it, but it cannot wander into the rest of the building — no unguarded access to your filesystem, network, or host environment unless you explicitly hand it the keys through the proxied tools. For any team nervous about "AI that runs code," that containment is the difference between an experiment you can approve and one your security team will veto outright.
What this means for your project: the architecture lets you capture the cost savings of code-writing agents without the usual "it can run anything on our server" risk. That trade-off — power inside a wall — is exactly the shape a business wants.
What you get out of the box
Pulled together, the included pieces map directly to the 80% that usually eats your timeline:
- Database persistence — agent runs survive restarts and are queryable, instead of vanishing when the process dies.
- Tracing — a record of decisions and tool calls, so a misbehaving agent is a debugging task, not a guessing game.
- Web UI — the author notes that testing via the CLI "became unwieldy," which is the honest reason every serious agent project eventually grows an interface.
- Human-in-the-loop — approval gates for actions you do not want a model taking unsupervised. For anything touching production, this is non-negotiable.
- LLM-independent function calling with auto-generated schemas — you are not locked to one model vendor, and you do not hand-write tool schemas. Define the function, get the schema.
That last point quietly saves real hours. Maintaining tool schemas by hand is tedious and error-prone; auto-generating them from your actual functions removes a whole category of bugs.
Real numbers: the only hard figure available today is the build cost — roughly five to six months of one experienced engineer's time to reach this point. Benchmark runners for both the autonomous agent and coding tasks are still "in the works," so there are no published performance scores yet. We will not invent them, and you should be skeptical of any agent framework that quotes capability numbers without a reproducible benchmark behind them.
Where it fits: build vs. buy vs. framework
For a team deciding how to add agents to a product, there are three honest paths.
Build from scratch. Maximum control, maximum cost. You will rebuild persistence, tracing, sandboxing, and a UI — the exact things Nous already ships. Justified only if your needs are genuinely unusual.
Buy a managed platform. Fastest to a demo, but you rent the roadmap and the pricing, and your agent logic lives on someone else's infrastructure. Fine for non-core experiments, riskier for anything central to your product.
Adopt an open-source framework. The middle path: you skip the plumbing but keep ownership and the ability to read every line. Nous sits here, alongside LangChain, CrewAI, and others.
The honest trade-offs for Nous specifically: it is young, single-author, and pre-benchmark, so it carries the usual early-project risks around stability and long-term maintenance. Against that, it is TypeScript-native (rare and valuable for product teams already in that stack), it is genuinely batteries-included, and its code-execution architecture is more cost-efficient by design than turn-by-turn loops. Being open source, the worst-case exit is also survivable — you can fork it.
Here is what we recommend: if your team lives in TypeScript and you are at the experiment stage with agents, clone it and run the autonomous agent on one real internal task — the same way its author did with a Jira ticket. A bounded internal chore (code review, a routine ops request) is the right first test: low blast radius, clear success criteria, real signal on whether the framework fits how you work. Keep it away from anything customer-facing until the benchmarks land and you have run it long enough to trust the human-in-the-loop gates.
Key takeaway for business
Three conclusions worth carrying into your next planning meeting:
The value of an agent framework is the boring 80%, not the LLM call. Nous earns attention because it ships persistence, tracing, a UI, sandboxing, and approval gates — the parts that otherwise consume your timeline. Judge any framework on that, not on demo polish.
Code-writing agents in a sandbox are a real cost lever. Generating and running validated code in one loop cuts the LLM round-trips that drive both your bill and your latency, and the WebAssembly sandbox keeps that power contained. The mechanism is sound even before the benchmarks confirm the size of the win.
Match the tool to your stack and your risk tolerance. For TypeScript teams tired of Python-first tooling and heavy abstractions, this is a credible option to pilot on a low-stakes internal task. It is early, so treat it as a serious experiment, not a production commitment — yet.
Put simply: Nous is a thoughtfully built, TypeScript-native answer to a problem every team building agents runs into. The architecture choices are the right ones. The missing piece is published proof of capability — and that is exactly what to wait for before betting anything important on it.
This article is based on publicly available sources and may contain inaccuracies.


