Tailored Inference is how we apply programmable heterogeneity to our partners' hardest problems: the right composition of models and disaggregated silicon, optimised against the shape of the workload.

Across cybersecurity, finance, and enterprise, this approach is redrawing the frontier of cost and speed, without sacrificing capability. Here we show some examples of this applied with our partners.

Agent security with HelmGuard: 77× cheaper and 10× faster at catching sensitive data exfiltration

HelmGuard is building an agent platform for governance, risk, and compliance and security. They work with enterprises and startups to automate workflows in third-party risk management, security certification, and AI governance.

Together with HelmGuard, we discovered a new family of data-leak detection systems on the Pareto frontier of cost and speed, at frontier-model detection quality. Using closed-source frontier-models, the cost prohibits meaningful scale, and the latency prevents any real-time analysis. The solutions we discovered are inexpensive enough to enable deployment across millions of agentic traces and fast enough to stop sensitive data exfiltration in real time. These systems achieve this performance by leveraging both hardware and model heterogeneity. We use wafer-scale inference from Cerebras where speed is most critical, commodity GPUs batched asynchronously where cost decides, and models ranging from small open weights to TypeSafe's frontier model depending on what each subtask demands.

The tools that make an agent useful are often what make it unsafe. Consider a customer support agent built to: (1) investigate logs and service configuration, (2) receive input from users or read public documentation, and (3) report back to that user about their ticket. A hidden instruction in anything the agent reads, such as a web page or a ticket, is enough to steer an agent to expose sensitive data. No skilled attacker is needed, and no alarm is triggered. Detection requires an independent judge, one with enough context to know what the agent is doing, why, and what this particular company considers sensitive.

That judge can be deployed in one of two modes. Post hoc, it reads the completed trace after the fact and determines whether any sensitive data leaked. The data is already gone, but exposed credentials can still be rotated. In real time, it runs before every outbound tool call and blocks the ones that would cause a leak, preventing the data from leaving in the first place. The second is far more valuable and far harder to deploy. On the critical path, the judge's latency is added to every call, and its cost multiplies by tool-call volume rather than trace count.

The most naive implementation of this judge is a single model call that reads the whole trace up to the point of decision. In the post hoc case, that is the completed trace. In real time, it is everything before and including the tool call in question. Both require a model that can hold the entire trace in context and make every judgement simultaneously.

In practice, not every judgement needs a model. Some stages can be resolved algorithmically: pulling the read and send calls out of a trace is an extraction, determining which data could reach which send is a set computation, and discarding the permitted sends is a filter. Of the judgements that remain, only three genuinely need a model: did this step touch sensitive data, is what's leaving still sensitive after transformation, and did the user intend for this to happen? The task decomposes into a heterogeneous system of model calls and classical algorithms.

Decomposition does two things at once. First, each model call becomes tightly scoped to a specific subtask, requiring less context, so a smaller model can answer it well. Second, each call becomes independently assignable: it gets its own model and its own hardware, each chosen against that call's context length and latency budget. What was previously a single model choice becomes a search space over the shape of the workflow graph, the model at each node, and the silicon each one runs on. Searching that space does not return one solution. It returns a family of them.

That family spans orders of magnitude in cost and speed. Four of them provide optimal tradeoffs for different deployment needs, tracing the Pareto frontier.

When cost is the only constraint and latency is irrelevant, every model call of a post hoc analysis can be batched and run asynchronously, off the critical path. That brings the price to $0.08 per 1,000 traces analysed, 77x cheaper than the closed-source monolithic judge.

When latency is critical for a real-time deployment, the graph is restructured to optimally exploit Cerebras' wafer-scale inference. That returns a verdict 10x faster than the real-time baseline, at less than half the price.

For deployments that need to balance the two, we can build a system that is 5.2x faster and 26x cheaper than that same real-time baseline by integrating the TypeSafe model. TypeSafe AI, founded by RLHF/ChatGPT co-creator Diogo Almeida, provided us early access to their frontier model, which is designed specifically for use within software systems.

The fourth takes the same graph as the cost-optimised solution and runs it synchronously, giving 26x the cost saving and a 2x median speedup over the post hoc baseline.

Where the closed-source judge offers one fixed point, a family of systems beats it on cost, on speed, or on both, each tailored to the needs of the deployment.

Tailored Inference does not just make real-time monitoring cheaper. It makes it viable. A real-time judge built on the closed-source monolithic model adds 2.77s and $8.98 per 1,000 traces to every outbound tool call, and an agent makes many calls per trace. At that price, real-time monitoring is something you run on a sample, or on your highest-risk customers, or not at all. Cerebras' wafer-scale inference returns a verdict in 0.28s for the most latency-critical decisions, and the balanced configuration decides in 0.53s for $0.34. Both are fast enough and cheap enough to run on every call the agent makes.

"At HelmGuard, we believe fast, abundant inference will be the key to security in a world of superintelligent cyber offensive capabilities. Callosum have shown we can bring down our inference costs and completion time by an order of magnitude, unlocking entirely new use cases we can bring to our enterprise clients."
— Jack Miller, CTO, HelmGuard

Our collaboration with HelmGuard is one concrete example of programmable heterogeneity in practice. A single model call knows nothing about your environment, your domain, or the shape of your task, so it cannot exploit any of them. Tailored Inference can. It breaks a task into parts, each with its own model and its own silicon, giving you access to the optimal system for your deployment needs.

Finance automation with Round Treasury: 7.5× faster document extraction

Round Treasury builds agentic infrastructure for finance teams, automating workflows across the entire financial function from treasury management to accounts payable and payroll. Their invoice and receipt pipeline extracts structured data from documents through a multi-turn workflow, with validation at each step.

Running through Callosum, mean extraction time fell from 15.9s to 2.1s per document, and the most complex cases improved by up to 20×. That is the difference between a background job and a live one.

"By switching to Callosum and using the same models the team saw an average 7.5× faster response, and in the complex cases up to 20× faster. This allows the team to improve the product by having the document ingested live on the dashboard instead of in the background."
— Hayyaan Ahmad, Co-Founder, Round Treasury

Model governance with Deliverance: 10× faster on production workflows

Deliverance AI builds an agentic operating system for enterprises running AI in regulated and sovereign environments, executing agents inside the customer's own infrastructure with governance, audit trails, and cost attribution built in. Its SmartRouter classifies every request across model tiers and directs it to the best fit on performance, cost, and risk.

"A four-agent workflow our customers run every day went from sixty-four seconds to six and a half. That is nearly ten times faster on real work, not a lab demo. Our customers do not buy tokens, they buy outcomes, and this is return on investment they can measure with a stopwatch."
— Mick McNeil, CEO, Deliverance AI