Your API? 0.2% of your context window

Make your AI Agents talk to APIs is easy and fun. It's just that bigger APIs are a worst-case workload for agents. Raw API definitions in the prompt overflows context so easily. I mean, we tried that. But all we got is hallucinated endpoints and unreliable responses.

That's something MCP helps with. You just wrap your API as MCP tools, and you're good to go. That's what we thought. Actually, the repeated schemas come with a cost (tokens), too.

I'm glad to say, we found something better. It's called Agent and our newest product, tightly integrated with our set of tools for your API. And here is why it might be better than your average MCP server:

Agent keeps the tool surface fixed and super small. It fetches just-in-time details. The result is smaller context, fewer steps, and better routing. And happy agents. :-)

Get Started

The problem

If you dump the full OpenAPI document into the prompt, you often blow past the model's context window before the model can do any work. That's exactly what happens with the, for example, the Zoom Meetings API.

Even when the API is smaller, like Notions API, raw OpenAPI is so expensive: It works, sure, but you pay a steep token tax every run. MCP reduces cost a lot, but native MCP still carries schema tokens for every single endpoint.

Agent collapses that into three tools and pulls only the schema it needs.

Benchmarking what we built

We ran a few benchmarks to test Agent with real-world APIs. And the results are so good, but take a look yourself:

Benchmark setup

We ran identical tasks across three approaches:

1. Raw OpenAPI documents in prompt
2. Native MCP server (one tool per endpoint)
3. Agent (3 tools: summarize, search and execute)

We used Zoom Meetings API (list, create, update) and Notions API (search, create page, get workspace). Example Notion prompts are aligned with Notion's MCP tools guide.

Token counting was done with tiktoken.

Zoom Mettings

Summary

Schema Cost (200k context)

Notion

Summary

Schema Cost (200k context)

The Results

Guess who's the clear winner with just 0.2% of your context window: Agent. Why is that?

1. Native MCP scales with endpoint count. Agent does not. Three tools cover the entire API.

2. Instead of loading the full API definition upfront, the agent calls a tiny version, with just the endpoints and schemas it needs.

3. The schema footprint is tiny (hundreds of tokens) even for large APIs like the Zoom Meetings API.

How it works

1. Upload your OpenAPI document to Scalar.
2. Scalar augments it for search and execution.
3. Agents connect via MCP with three tools:
   • summarize-openapi-specs (short summary of specs and available endpoints)
   • search-openapi-operations (minified OpenAPI documents for the endpoints matching the user's search), and
   • execute-request

Try it

You can use Agent in two ways:

1. Chat UI: upload your OpenAPI and chat at agent.scalar.com.
2. Agent SDK: connect to Scalar MCP servers from your agent runtime (Vercel AI SDK, OpenAI Agents SDK, Anthropic Claude SDK).

import { Agent, MCPServerStreamableHttp, run } from '@openai/agents'
import { agentScalar } from '@scalar-org/agent-sdk'

const scalar = agentScalar({
  agentKey: 'YOUR_AGENT_KEY',
})

const session = await scalar.session()

const serverOptions = session.createOpenAIMCPServerOptions()
const servers = serverOptions.map((opts) => new MCPServerStreamableHttp(opts))
await Promise.all(servers.map((s) => s.connect()))

const agent = new Agent({
  name: 'api-agent',
  instructions: 'You help users interact with APIs.',
  mcpServers: servers,
})

const result = await run(agent, 'pls list available endpoints in the zoom api thanks')

await Promise.all(servers.map((s) => s.close()))

Agent is able to scale across N APIs that you want your agent to have access to, without flooding the context window and yielding the most accurate tool calling. Crazy, eh?

Mar 5, 2026