Ramp’s Laminar Shows Why AI Agent Harnesses Are Becoming Core Infrastructure

Oct 22, 2026 650 views
glowing code

Ramp’s six-week build of Laminar points to a change in how companies think about AI agents: the infrastructure around an agent may matter as much as the model it calls. The fintech company now uses its in-house harness across its agent products, bringing execution, sandboxing, observability and asynchronous work into a shared platform.

That choice followed months of evaluating managed agent APIs, open-source frameworks and third-party platforms. Ramp concluded that an internal system would give its teams more control over model choice, debugging and product-specific needs. “We studied the other offerings on the market and decided that we could do better, move faster, and have stronger alignment to where we want to go by building in house,” Sam Kronick, the Ramp engineer behind Laminar, wrote in the company’s engineering blog.

The architecture also drew attention from LangChain CEO Harrison Chase. In an X post, he praised several of Laminar’s choices and linked them to work on LangChain’s Deep Agents. The two companies are building from different positions, but their efforts reflect the same practical question: which parts of an agent system should a company own?

Control over models and debugging

Ramp wanted to avoid depending on a single model provider. Its teams needed to choose models according to cost, speed and performance, and to see more clearly what agents were doing during execution. Engineers already examined traces to identify wasted tool calls, excessive context and errors. Ramp found existing observability tools made that work harder than necessary, so it built a debugging interface into Laminar.

Owning the platform also changes the pace of product development. Ramp’s harness engineers can work directly with the teams building agents, instead of waiting for a vendor to prioritize a requested feature. That arrangement can make iteration more responsive, though it also puts the work of maintaining the underlying system on Ramp.

Chase has emphasized model independence and observability in LangChain’s own projects. He also singled out Laminar’s separation of agent sessions from the environments that execute code, a decision that helps the platform support a broader range of workloads.

Sessions persist while sandboxes come and go

Laminar serves products with different operating patterns, from customer service agents to Ramp Inspect, Ramp’s cloud coding agent, and Glass, a product for longer-running collaborative work. These systems need to preserve conversation history, handle human approvals and move work across environments. A harness designed only to run a short sequence of model and tool calls would leave much of that coordination to each product team.

Ramp stores session history and execution state separately. A session can remain active even as its code sandbox starts, stops or changes. That separation gives the system room to manage long-running work without tying the life of a conversation to a single execution environment.

Chase endorsed Kronick’s point that production harnesses involve much more than a basic execution loop, writing “+100 to this” as he pointed to LangChain’s Deep Agents work. He has also described the sandbox-as-a-tool approach as a growing pattern. Keeping orchestration and credentials outside the sandbox can help teams contain agents that run code they don’t fully trust, a concern also raised in work on isolating agents that execute untrusted code.

Asynchronous work and shared access controls

Laminar supports agents that continue working while other steps remain unfinished. That non-blocking model suits tasks that take time or require coordination, and it avoids forcing every part of a workflow to wait on a single synchronous sequence. Chase has called asynchronous agents the direction of travel and said LangChain is developing similar capabilities for Deep Agents.

Ramp’s Connectors Service provides another shared layer. It puts authentication, credentials, access controls and tool execution behind one API. Instead of handling those pieces separately in each agent, product teams can rely on a central service to manage how agents reach external systems.

LangChain is exploring comparable features for managed Deep Agents. The pattern matters as agent deployments spread across products: a common access layer gives platform teams one place to govern credential handling and tool permissions, while individual agents can focus on their own tasks.

Model routing puts cost decisions inside the harness

The harness can also influence inference costs by selecting a model based on the work at hand. In an October 1 engineering post, LangChain described adding model selection to Open SWE, its open-source coding agent, at the harness level. A router assesses the initial request and assigns one of three models according to expected complexity: GLM-5.3-Flash for simpler tasks, GPT-5.6 Sol for intermediate work, and GPT-6 Astra for the most demanding requests.

LangChain reported results from 973 agent threads. Median language-model cost fell from $2.61 per thread to $0.94, a 64 percent reduction compared with sending every task to GPT-6 Astra. Ninety percent of requests went to one of the two lower-cost tiers. Merged pull request rates were 29.2 percent for routed threads and 27.3 percent for the control group; the difference wasn’t statistically significant.

LangChain’s argument is that a harness can make a better routing decision than a generic LLM gateway because it has more information about the agent’s prompts, tools and domain context. LangChain uses model-selection middleware to choose at the start of a thread. The reported trial shows the potential value of routing when tasks vary in difficulty, but it doesn’t establish whether a custom harness costs less to build or operate. Ramp wasn’t part of that experiment.

Six weeks to build, longer to maintain

Ramp says coding agents generated all of Laminar’s initial code, with experienced engineers directing the architecture and implementation. That helps explain how a first version could arrive in six weeks. It doesn’t answer the longer-term question: who handles incidents, updates the platform and supports the teams whose products depend on it?

Ramp hasn’t published operating-cost comparisons or benchmarks against competing platforms, so the available information can’t settle whether its in-house approach is cheaper. Building quickly is only one part of the calculation; an internal harness also creates continuing engineering work. For companies weighing the choice, the relevant costs include both the initial build and the expertise needed to keep the system reliable as agent products evolve.

LangChain offers a different route: adopt a framework that supplies much of the supporting infrastructure rather than starting from scratch. Other vendors are also open-sourcing agent harnesses, giving teams more ways to adopt shared components. The practical decision will depend on how much control a company needs, how quickly its agent requirements change and whether it can sustain a dedicated platform team.

Laminar’s strongest signal may be that agent infrastructure is becoming a product engineering concern, not just a model integration detail. As agents gain persistent sessions, access to tools and longer-running responsibilities, teams will need to make explicit choices about execution, security, observability and cost. Ramp’s build makes those choices visible—and gives other engineering teams a concrete architecture to evaluate.

The post Ramp built an AI agent harness in six weeks — and LangChain’s CEO says it’s part of a bigger shift appeared first on The New Stack.

Source: Amanda Caswell · thenewstack.io

Comments

Sign in to comment.
No comments yet. Be the first to comment.

Related Articles

Ramp built an AI agent harness in six weeks — and LangCha...