Nasiko launched Open Runtime on November 16, 2026, pitching a proxy control plane that sits under existing coding and operations agents, unifies token accounting across vendors, and hard-stops runs when a team burns through its budget. The product announcement and marketing site publish concrete numbers—42% fewer input tokens and 40% lower cost per correct answer on 50 log-backed questions—rather than a vague “save money with AI” tagline.
For teams already running Claude Code skills, Cursor MCP stacks, or Together’s high-touch agent evals, the problem Nasiko names is familiar: every provider dashboard slices spend differently, retries re-read the same logs, and nobody owns the kill switch when an incident agent loops.
TL;DR
| Layer | What Nasiko adds | What it does not replace |
|---|---|---|
| See | Auto-discovery of active agents, per-run traces | Your identity provider or SOC2 program |
| Control | Gateway ACLs on tools/models, budget caps | Application-level business logic |
| Cut | Compression, caching, central model picks | Model quality tuning in your prompts |
Why agent token spend needs a runtime, not another dashboard
Nasiko’s narrative starts with adoption outpacing governance: executives want agent ROI, but finance sees scattered invoices and security sees opaque tool calls. That matches explainx.ai’s thread on API credit shocks and verification taxes on AI output.
The architectural bet is in-path proxying: every model and MCP call routes through Nasiko’s Agent Gateway so attribution happens before the provider bills you. Nasiko stresses no wrapper SDK in the hot path—important for teams who already fight desktop telemetry leaks and want fewer new binaries on developer laptops.
What ships on day one
Nasiko trace view showing agent run steps and token costs
Image: Nasiko
According to the launch post, Open Runtime bundles:
- Agent auto scan — discovers coding agents running across teams and marks which are active.
- Unified cost schema — normalizes spend by team, model, agent, harness, and MCP tool.
- TokenOps caps — configurable ceilings with 80% warnings and 100% hard stops on the next model call.
- Cut levers — context selection/compression, caching recommendations, and per-agent model routing set centrally.
- OpenTelemetry traces — token and cost dimensions on spans for teams already exporting OTel.
Enterprise positioning adds assessment calls and longer retention; the free tier still advertises a token audit workflow.
The published 42% / 40% benchmarks
Agent orchestration gateway concept for token spend control
Nasiko’s homepage tables are unusually specific. On 50 questions over real system logs with gpt-4o, they report:
| Metric | Compression off | Compression on |
|---|---|---|
| Input tokens | 617,202 | 357,958 (42% fewer) |
| Cost per correct answer (list price) | $0.037 | $0.022 (40% lower) |
| Correct answers | 44 / 50 | 44 / 50 |
A second table on 102 record lookups shows four fewer correct answers on the larger model after compression (100 → 96), which Nasiko discloses rather than hiding.
Treat these as vendor benchmarks, not guarantees on your traces. They nonetheless show where savings come from: shrinking tool payloads (logs, search hits, tickets) before the model reads them—a different knob than speculative decoding research.
Gateway permissions and the MCP angle
Nasiko places MCP tool gating beside spend controls: allow, ask, or block each call with auditing. That intersects Hugging Face OpenRouter routing and Baseten’s inference efficiency guidance, but targets operator policy rather than kernel math.
Teams running ChatMate-style remote execution risks should note: a gateway only helps when all production harnesses actually route through it. Shadow agents on personal API keys bypass the runtime entirely.
How to try it without betting the budget
Nasiko’s install story is one command from laptop to traced deployment with no code changes, per the announcement. Pragmatic rollout:
- Mirror one team’s staging agents through the gateway for a week.
- Compare provider invoices to Nasiko’s unified schema—not only headline token counts.
- Turn on compression on the noisiest tool (usually logs or search), watch accuracy-sensitive tasks first.
- Set caps on exploratory agents before on-call automations.
If you already standardize on OpenRouter, Nasiko can sit above or beside it; the value proposition is cross-provider attribution plus enforcement, not cheaper list prices by itself.
What is token spend in AI agents?
Search data shows operators ask “what is token spend” when finance receives surprise OpenAI or Anthropic invoices after an on-call agent looped. Token spend is the metered usage providers bill per input and output token, multiplied across models, tools, and retries.
Nasiko’s pitch is to make that spend legible per agent instead of per API key. That matters because:
- Retries on log-heavy tools inflate input tokens faster than output tokens.
- Model upgrades silently shift per-step price when routing defaults change.
- MCP tools return fat JSON that models re-ingest every turn unless compressed.
Without a proxy, FinOps teams build spreadsheets from five portals. With a proxy, they can attach budgets to the agent name your incident channel already knows.
FinOps workflow Nasiko describes
The launch narrative implies a monthly operating rhythm:
- Discover which harnesses are live (auto scan).
- Attribute last month’s spend by team and agent.
- Set caps before the next release train.
- Enable compression on the top three noisy tools.
- Review traces when alerts fire at 80%.
That rhythm mirrors Claude usage limit timelines but adds pre-payoff guardrails—closer to cloud cost anomaly detection than static rate limits.
| Role | Question Nasiko wants to answer |
|---|---|
| Platform lead | Which agent tripled cost after Tuesday’s deploy? |
| Security | Which MCP tools did the on-call agent touch? |
| Finance | What is run-rate by team before renewal? |
| Developer | Did compression change answer quality on my eval set? |
Security review checklist
Before routing production traffic:
- TLS termination — where keys live, who can decrypt traces.
- Bypass paths — personal API keys, local ollama routes, CI secrets.
- Tool ACL defaults — deny-by-default for write MCP tools.
- Data residency — whether traces include customer log text.
- Kill switch — who can lift a 100% cap during incidents.
Nasiko markets infinite-loop prevention; treat budget caps as financial containment, not a substitute for tool permission design.
How Nasiko compares to DIY observability
Teams already stitch OpenTelemetry, Langfuse, and provider dashboards. Nasiko’s differentiation is enforcement in the request path—blocking the next model call—not only charting yesterday’s overspend.
DIY stacks excel when you own custom evals and heterogeneous runners. Nasiko fits when dozens of coding agents share one corporate gateway and finance wants hard stops without forking every harness.
Neither replaces good prompt design or codec-style agent review. They make runaway loops expensive for minutes, not days.
Workshops and team readiness
If your organization is moving from chat experiments to always-on agents, spend governance belongs in the same workshop track as MCP safety. explainx.ai’s live workshops cover Claude Code, Copilot Studio, and agent orchestration with the assumption that token meters will exist—Nasiko is one vendor answer, not the only pattern.
Deployment patterns that survive security review
Enterprises usually adopt gateways in three phases:
Phase A — read-only mirror. Route 10% of staging traffic through Nasiko without caps. Export OpenTelemetry to your existing SIEM. Confirm PII fields in tool payloads match policy.
Phase B — budgets on non-production. Enable 80/100% caps for QA agents only. Measure how often legitimate evals hit the ceiling—if often, your eval harness is too chatty, not too cheap.
Phase C — production choke point. Require corp laptops to use a single proxy endpoint for provider keys. Block raw provider keys in CI except break-glass roles.
This mirrors how teams adopted API gateways for microservices—except the payloads are prompts, not JSON CRUD.
Cost story worked example (illustrative math)
Suppose an incident agent reads 400k input tokens per night from logs at gpt-4o list pricing, and retries double reads after failures. A 42% input cut on log payloads (Nasiko’s published log study) lands near 168k tokens saved per night before retries—even more if retries shrink too.
Multiply by 30 nights and a $2 per million input token list price for intuition-only math near $10 saved per agent per month on input alone. Real bills vary with cached tokens, batch discounts, and model mix—run Nasiko’s audit on your traces instead of copying the illustration.
The point is not the dollar figure; it is that compression targets tool bloat, which scales with incident frequency, not headcount.
Document baseline token histograms before enabling compression so finance can prove savings in the next QBR instead of debating vendor slides.
Limits and honest gaps
- Cryptocurrency press reposts exist; explainx.ai sources are Nasiko’s own site, not crypto outlets.
- 50% routing savings appears in marketing headers; the published tables substantiate 42% on logs, not every workload.
- Security reviews should ask where runtime keys live and whether local agents can bypass proxy TLS.
Related reading
- Together AI agent evals at 97%
- Google Stitch skills and MCP installs
- Claude Code bughunter skills
- M365 ChatMate remote prompt CVE
- Baseten frontier inference efficiency
- Hugging Face OpenRouter routing
Launch details reflect Nasiko’s November 16, 2026 blog and product pages.
