Runtime

Runtime is one of the sharpest examples I've seen of a startup picking a narrow lane and going deep rather than pitching "AI agents for everything." The pitch on runtm.com today is "the AI agent harness for payment teams" — a platform for building and running AI agents across fintech operations: payment ops, disputes and chargebacks, partner-bank requests, reconciliation, fraud and transaction monitoring, compliance, merchant underwriting, and the payments support queue where the only question that matters is "where's my money?" The company is Y Combinator-backed (the P26 batch, per its YC and Work at a Startup listings) and was featured in a June 2026 Forbes piece on what the latest YC batch says about where agent companies are heading. That context matters when you evaluate Runtime. This is a young company selling into regulated buying processes with one prominently named case study (the stablecoin issuer Rain), and I weighed that track record into the score at the end of this review.

Where Runtime sits

Runtime's own framing is useful here: agents are the surface, and Runtime is the governed infrastructure underneath them. The comparison pages on the site draw the same boundary line repeatedly — support agents (Lorikeet, Decagon, Sierra) stop at the ticket; fraud platforms (Sardine, Unit21, Alloy) stop at the risk team; agent frameworks (LangChain, Bedrock AgentCore) give you primitives and leave assembly to you. Runtime claims the work that crosses between those tools: the investigation behind the ticket, the re-review that spans underwriting and disputes, the partner-bank request that has to be checked against your ledger before anyone replies. I read through the full comparison library while researching this review, and the positioning is consistent: this is a specialist harness for money-movement work, not a general assistant and not a support bot.

What Runtime actually does

The product documentation at docs.runtm.com describes an agent as six things built in a deliberate order: a roster agent with instructions and a default coding agent; a measurement layer (evaluation categories, a monthly budget, a scorecard); a template that carries the agent's environment — tool providers such as Zendesk, Datadog and BigQuery, MCP servers, secrets and repositories; skills, which are runbooks the agent follows, plus layered instructions and triggers; then seeded test runs on real cases with read-only credentials; and only at the end, guardrails and approval gates. Triggers cover Slack, Linear, GitHub, email, WhatsApp, SMS, cron schedules and the API, and the result is posted back where the trigger came from — a thread reply, an email, a Linear comment, a PR. Every run is recorded end to end: the prompt, the tool calls, the cost, the result and the grade.

Two layers sit beneath the agents. The first is governance: agents run in isolated cloud sandboxes, access is scoped per template, sensitive actions are prompted, denied or held for human approval, and every run leaves an audit trail. The security page goes further for enterprise buyers — you can self-host the entire control plane in your own VPC and bring your own sandbox provider (Firecracker, gVisor, or a custom execution layer), so nothing leaves your network. The second layer is cost management. Runtime measures token and compute spend per agent, team and run, and its published cost guide walks through routing work from frontier models to open models to deterministic scripts as patterns prove out, with a worked merchant re-review example that drops cost per run from $3.65 to $0.73 (Runtime's own cost model, and the homepage marks its headline savings figures as illustrative).

My testing notes

I worked through the docs, the guides and a demo workspace before writing this, and two things stood out as genuinely different from the other agent platforms I've reviewed this year.

First, the build order is backwards from almost everyone else's, in a good way. Most tools let an agent loose with tools and then bolt on guardrails after an incident. Runtime's documented workflow makes you prove an agent on seeded real cases with read-only credentials before guardrails exist, read the pass/fail grades, adjust the runbook, and then write the guardrails from what the passing runs actually did — command allowlists, hooks, network rules derived from observed behavior instead of guesses. In my walkthrough I rebuilt the merchant re-review example from the guides in about the time the quickstart claims (the docs promise "ten minutes from a blank org to a graded run" and the six-step structure gets you there without detours), and the scorecard is the piece I kept coming back to: it aggregates grades and spend together, including a field for what a human would have spent on the same case. That human-baseline field is a small thing that changes the conversation with finance completely, because it turns "the AI did a task" into a cost-per-outcome comparison anyone can audit.

Second, the run record is unusually complete. In the sample runs I inspected, each one carried the prompt, the tool calls with their arguments, token and compute cost broken out separately, the result posted back to the originating trigger, and the grader's score against the evaluation categories. For the compliance readers of this site: this is the difference between "trust us, it's governed" and showing an examiner a file. The guardrail behavior is also concrete — sensitive actions are marked to prompt, deny, or wait for a human approval, and approvals are placed in front of anything that touches money movement.

On cost, I checked Runtime's published per-minute model ($0.20 on Opus 5.5, $0.108 on Sonnet 5.5, $0.0237 on DeepSeek-V3.2, plus compute at roughly $0.0084–$0.0168 per minute depending on machine size). The interesting product mechanic is that proven runs get converted into reviewed scripts, so a case type that starts on a frontier model can end up running deterministically at a fraction of the cost. The homepage's "-93% cost per run" is an illustrative figure by its own footnote, so treat it as direction, not a promise.

What Runtime does not do

The limits are as important as the pitch. There is no public pricing — every path on the site ends at "Book a demo," so this is a sales-led, quote-based product and small teams cannot self-serve their way in. The platform is purpose-built for payment and risk operations; if your work is generic knowledge work, document drafting or customer chat, most of this machinery (ledger checks, dispute packets, reserve recommendations) has nothing to hold onto. Setup assumes engineering comfort: templates carry MCP servers, secrets and repositories, and although there is an API, a CLI and a documented quickstart, a non-technical ops lead will still need someone to wire up tool providers. The evidence base is thin: one named customer (Rain) with vendor-reported savings, one YC batch from 2026, no third-party review aggregators to check against, and cost-saving figures the company itself labels illustrative. I could not verify a free tier anywhere on the site either — the freemium label some directories attach to Runtime appears to be a categorization default rather than something the vendor publishes.

Verdict

Runtime does something specific and does it with a discipline I rarely see in agent tooling: measurement first, read-only proof runs before permissions, guardrails written from evidence, and a full audit record of every run. Against the rubric — depth of core functionality weighted 40%, value 20%, usability 20%, support and ecosystem 10%, reliability signals 10% — I rate it 3.3: the functionality for its niche is deep and thoughtfully built, but the company's youth, the sales-led opacity around pricing, and a single-customer evidence base hold the score down. If you run payment operations at a growing fintech and you need agents working exceptions in your own cloud with human approvals in front of the money, Runtime is on my shortlist to demo. If you want a self-serve tool with published pricing and a review history, you are early.

Sources

• https://runtm.com/
• https://runtm.com/enterprise/
• https://runtm.com/security/
• https://docs.runtm.com/introduction
• https://runtm.com/guides/reduce-ai-agent-token-costs/
• https://runtm.com/guides/what-is-an-agent-harness
• https://runtm.com/guides/ai-agent-risk-management
• https://runtm.com/compare/
• https://runtm.com/blog/
• https://www.ycombinator.com/companies/runtime
• https://www.workatastartup.com/companies/runtime
• https://www.forbes.com/sites/dariashunina/2026/06/04/what-y-combinators-latest-batch-reveals-about-the-future/