Developer Signals That Shaped Open Runtime

Listening before building
An AI agent demo can come together in an afternoon. Getting that agent to run reliably, affordably, and safely in production is a different problem, and it's the one we hear about most.
Over the past year, our Developer Relations team has been active across India and the US. We've shown up at hackathons, meetups, workshops, and conferences, worked alongside partners, and spent a lot of time in our online community. Those conversations shaped how we built Open Runtime.
A pattern emerged quickly. Developers come to us talking about agents, and within minutes the conversation turns to everything around the agent: which model to call, how to connect tools, what it all costs, where it should run, and who gets access. Here are the five signals we heard most often, and how they shaped what we're launching.
Signal one: "Which model?" is now an everyday question
Few teams we talk with are committed to a single model anymore. Developers tell us they want a fast, inexpensive model for simple steps, a stronger model for complex reasoning, and the freedom to switch when a new release changes the math. What they don't want is to rewrite their agents every time.
That turns model selection from a one-time configuration choice into a decision made on every request. It belongs in the runtime, not in application code scattered across a dozen agents.
Open Runtime's Open LLM Router is our answer. It lets teams use any LLM in any agent, including coding agents, and route each request to the model that fits the job.

Signal two: Agents are only as useful as what they can connect to
An agent that only generates text has limited value. The moment it needs to take action, like querying a database, filing a ticket, or calling an internal API, the hard part shifts. Developers tell us the challenge becomes tools, permissions, and coordinating work that spans multiple steps and often multiple agents.
MCP comes up in nearly every conversation. So do the problems that follow adoption: tool sprawl, unclear permissions, and little visibility into what an agent actually did. These concerns aren't limited to coding agents. Teams deploying agents across the company, in support, operations, and internal tooling, raise them just as often.
Open Runtime addresses this with MCP Hub and MCP Gateway, which give teams one place to manage the tools their agents use and the policies that govern them. Our Meta-Harness coordinates multi-agent workflows, and full session traces show what happened at every step.

Signal three: Token spend gets noticed fast
Costs are easy to ignore in a prototype. They're much harder to ignore once agents run multi-step workloads where every tool call, retry, and growing context window adds up. Token spend consistently draws developers into our hands-on sessions, and the question is usually the same: where is the money going, and how do we bring it down?
That's the problem TokenOps was built to solve. Open Runtime gives teams visibility into token usage and reduces spend through caching, compression, and routing each task to the right model. For coding agents, savings come from routing to cheaper LLMs and tool compression.

Signal four: Developers want a choice in where agents run
There's no single answer to where agents should run, and developers tell us so. Some teams need everything inside their own infrastructure for security, compliance, or cost reasons. Others want a managed service so they can focus on building agents instead of operating them. Many haven't decided yet.
Interest in our open-source project has been one of the most consistent threads in community conversations. So has curiosity about a managed option.
Open Runtime supports both paths. Teams can self-host the open-source runtime or join the waitlist for hosted Open Runtime, managed by Nasiko. We don't think teams should have to commit to a deployment model before they understand their own requirements.
Signal five: Teams want to know who can run which agents, and what they're allowed to do
As agents spread across a company, a new question keeps coming up: who is actually running agents, and who gave them access? Developers and platform teams tell us agents often appear faster than anyone can track them. One team spins up a coding agent, another connects an agent to customer data, and soon no one has the full picture.
What teams ask for is straightforward. They want an inventory of every agent in use, clear rules about who can run them, and a way to require approval before an agent takes a sensitive action. They also want limits that apply per team or per agent, so one runaway workflow doesn't affect everyone else.
Open Runtime addresses this through See and Control. Discovery scans for agents automatically, so teams know what's running. Runtime Controls set permissions and approvals per agent and tool, and budgets with alerts keep each team or agent within its limits.

What the waitlist confirmed
Conversations tell you what people care about. Data tells you whether you heard them right. When developers joined our waitlist, we asked which areas interested them most, and the results lined up closely with what we'd been hearing.
AI agents were the clear starting point, selected by 92% of signups. Interest extended well beyond the agent itself: 44% selected LLM routing, 37% coding harnesses, 36% MCP servers, 35% workflows, and 25% spend tracking. Signups could choose more than one area.
Deployment preferences were split, too. Among those who answered, 49% planned to self-host the open-source server, 26% preferred Nasiko-managed hosting, and 25% weren't sure yet.
These are self-selected interest signals, not usage data. Still, they confirmed what the community had been telling us: developers start with agents and quickly need everything around them.
How these signals shaped Open Runtime
Taken together, these signals point to one conclusion. Routing, tool connectivity, workflows, spend, deployment choice, and access management aren't separate problems to solve with separate tools. They're parts of the same runtime.
That's how we built Open Runtime: a vendor-neutral runtime for AI agents, written in Rust, and organized around three things teams need to do with their agents: see them, control them, and cut what they cost.
- See: every agent your teams run, which ones are active, and what each costs per team, model, and agent. Discovery scans for agents automatically, and one cost schema works across vendors.
- Control: caps and alerts per team or agent, with a warning at 80% of budget and a pause at the limit. Runtime Controls add permissions and approvals per agent and tool.
- Cut: clear guidance on where to spend less, with fewer tokens for the same work and the right model for each agent. Context selection and compression, caching recommendations, and per-agent routing back this up. In our testing, this used 50% fewer tokens on standard SWE benchmarks.
Instead of stitching together a discovery tool, a cost dashboard, a gateway, and a router, teams get one runtime that brings them together, whether they're running coding agents or agents across the company.
Keep the signals coming
Open Runtime is shaped by what developers told us, and we're not done listening. Our team will keep showing up for developers in India and the US, at hackathons, meetups, and workshops, and in our online community, to learn why teams build the way they do and where they still get stuck.
If you're building with agents, we'd like to hear from you.
- Try the open-source runtime on GitHub.
- Tell us how you're running agents today in our community.


