Blogs

Introducing Nasiko, the Open Runtime for agents

Rahul Todkar, CEO and founder

Launch art: concentric orbits of glowing tiles around the Nasiko mark on a gold gradient, beside the words “The Open Runtime for agents starts now” and the Nasiko wordmark.

One runtime to see your agents, control how they run, and cut what they spend. Available today.

Today we’re launching Nasiko, the Open Runtime for agents. We built it because the enterprises we talk to are adopting agents faster than they can manage them. Every company and leader is eager to get more done with AI agents and unlock massive ROI, but without proper tooling and capabilities, that ambition turns into cautious optimism.

Nasiko gives enterprise leaders visibility and control over their agents and what they spend, while developers keep using the agents, models, and workflows they already rely on. There’s no wrapper, no SDK in the code path, and no need to change agent code. Teams can connect costs to individual agents, models, MCP tools, and runs, and step in before runaway spend occurs. You can start with a free account today, or book a free assessment with our team to walk through your token spend, model usage, and agent workflows.

Enterprises today are struggling to get ROI from AI agents

Over the past year, I’ve talked with 100+ enterprise AI leaders, CTOs, and platform heads about how their companies use agents. This is the world I am deeply familiar with as a former technology, data, and AI leader. And I have heard loud and clear that enterprises are adopting agents faster than they can manage them, and this is a major bottleneck to unleashing the true potential of AI and LLMs. The same five problems kept coming up in my conversations:

  • Cost nobody can explain. Agent spend is climbing faster than anyone planned. The bill arrives as one number, and no one can say which agent, team, or task drove it. So, detailed visibility, attribution, and true ROI become very hard.
  • Agents nobody knows about. Shadow AI is real. With the top-down push of AI transformation, everyone has access to a variety of LLMs, agent-building frameworks, and harnesses. That means agent building is super easy, and before you know it, multiple agents are running in the background on laptops and in pipelines. No one has a comprehensive list of what is running at the individual, team, or organization level, and that creates so many challenges.
  • No real access control. Agents call whatever tools they can reach to accomplish a given task or goal. And, in the best-case scenario, they inherit permissions from a service account or your LDAP/RBAC systems. As agents get more autonomous, or collaborate with other agents, clear visibility, discretion, and control at a more granular level are critical.
  • Too many tools. Every team has their favorite harness, framework, and model provider. Add on top of that various access control, observability, registry, and memory management tools. And before you know it, engineers end up stitching together vendors and open-source packages to do the same job in slightly different ways.
  • No way to step in. And the last but most important scenario is when an agent runs through a budget or heads toward a risky action, nothing sits between noticing it and the damage it can cause. By the time someone reads the log, it might be too late.

These aren’t five separate problems. They’re one problem showing up in stages.

It starts with choice. Every team picks the agents, harnesses, and models that fit its work, which is exactly what should happen. But no one ends up with the whole picture. Leaders can’t say which agents are running, so they can’t explain the spend or tell which team and task drove it.

Then agents stop just answering questions and start using tools and taking actions. Now the missing picture isn’t only an engineering, ops, or finance problem. When an agent can change a record, call an outside system, or keep spending through a weekend, a report after the fact arrives too late. Leaders need to see the work and step in while it’s happening.

That gap is what keeps agents stuck at the pilot stage. Not capability, but visibility, optimization, and the ability to intervene.

Why we built Nasiko

A bill, a trace, or a log tells you what already happened, but it does not give a comprehensive picture of what it takes to manage AI agents in production. That is why we built Nasiko: so enterprise leaders and employees can have confidence, visibility, and peace of mind regarding their AI agents.

We built an autonomous, secure Open Runtime that sits under all of your agents, across the harnesses, model providers, and vendors that your teams already use. It’s open, so no team has to give up its tools to be part of the picture.

Teams use Nasiko in two ways. They connect the agents their engineers already run, and they deploy shared agents on Nasiko to run across the company.

It comes down to three promises: See your agents. Control how they run. Cut what they spend.

See: your agents and their token path, model spend

Start with what’s running. Nasiko’s agent auto scan discovers coding agents running across your teams and shows which are active. Open any run to follow what happened: its model calls, the agents it handed work to, and the tools it used.

Model spend lands in one cost schema across vendors, broken out by team, model, agent, and harness, instead of scattered across separate provider dashboards. The history builds as you go, so next quarter’s plan starts from real spend by team and agent instead of a guess.

Say an incident-response agent’s model spend tripled last week. The platform lead opens its runs, sees it re-reading the same logs on every retry, and knows which team owns the spend, all from the same view.

“Every Agent, Every Run. One command finds every agent your teams run. Open any run and see every step.” beside a Nasiko trace view of a Doc Writer session: a waterfall of planner, retriever, LLM and tool spans, with one LLM span’s cost, tokens and model in a side panel.

Control: caps, alerts and approvals in the run

As agents start taking actions and operating more independently, you need a way to step in if they don't follow a policy, rule, or guardrail. You may want to set caps per team or per agent. Nasiko warns at 80%, and at the limit it refuses the agent’s next model call through the Nasiko router, so spending stops while there’s still a decision to make.

Permissions and approvals work the same way per agent and per tool. You can allow a tool, block it, or require a person to approve before the agent uses it. An agent can read customer records on its own and still stop to ask before it issues a credit or changes an account. All these are necessary controls, especially as you put more and more agents in production.

Cut: reduce token waste

Cheaper tokens help, but they don’t fix how a run uses them. Increasingly, agents resend the same background, carry context they no longer need, and default to models bigger than the job requires. Nasiko gives you a lever for each:

  • Context selection and compression removes what the model doesn’t need before the call is sent.
  • Caching stores repeated context so agents don’t pay to resend it, and recommends what's worth caching.
  • Model selection per agent puts each agent on the model its work calls for, set once, centrally, across providers.

A research agent that resends the same background document on every call is a caching candidate. An agent drafting routine replies may not need the largest model available. Together, these levers help keep model spend from growing in step with adoption.

We measured what the Cut pillar is worth and the results were quite emphatic. In two studies run in October and November, we asked the same questions with Nasiko’s compression off and on. On real system logs, input tokens fell 42%, and model cost fell 40%, and the number of correct answers didn’t change. On public agent test data covering code search, incident debugging, codebase exploration, and issue triage, input tokens fell 33% while every value in the data survived compression, with the larger model losing four answers out of 102 and the smaller model losing none.

What one runtime gets you that a stitched stack doesn’t

With Nasiko, a team can inspect a run, attribute its model spend, and apply controls - all in the same place. The person who notices a problem looks at the same run as the person who can fix it, and no engineer has to switch tools to get there.

This unified approach to an open runtime for managing agents is resonating on both sides of the problem: with the developers who build agents, and with the enterprises that have to run them.

Developers. 11,900 developers have starred our open-source project on GitHub in a very short amount of time. These developers are usually the first to feel the pain of a stitched-together stack, and they tell us the same thing enterprise leaders do: they want one place to see what their agents are doing, without changing how they build them. Every issue they file and pull request they open makes the runtime better for everyone who runs it.

Enterprises. A growing number of companies are now running Nasiko with their own agents. They come to us with the problems above, and the first thing they usually ask to see is what’s actually running and what it costs.

Hearing the same need from both ends, from the developer building an agent to the leader accountable for it, is what gives us confidence that one open runtime is the right foundation for agents in production.

Open Runtime for agents starts now!

Create an account · Schedule a free assessment