Introducing Sign in with AgentOnboard for Agents

You open your terminal to run your agent. You want one ticket updated on Linear, customer feedback pulled from your database, and a summary posted to Slack.

Before your agent can type a single line, you are back in your configuration files.

You open mcp.json. Neon is running. GitHub is running. Your editor warns you that you are at 38 of your 40 allowed tools. Linear won't fit. You start unplugging servers to make room, rebooting sessions, and checking connection statuses just to get your agent to the starting line.

MCP became the industry default for good reason. It gave developers a common standard instead of writing custom wrappers for every model. When you plug in one or two tools for a local task, having a structured way for an agent to execute functions feels like magic.

The bill arrives the moment you try to build something truly autonomous.

Every MCP server you connect dumps its entire schema directly into the agent's context window. Three or four servers easily burn 60,000 to 100,000 tokens of schema before your system prompt even begins. Context bloat chokes the model's memory. As tool schemas pile up, tool-selection accuracy collapses from 95% down to under 15%.

To keep models from breaking, clients enforce hard ceilings. Cursor caps you at 40 tools; other environments silently drop the rest.

You quickly discover the reality: your agent is not autonomous.

You are trapped in connection hell. You spend your day connecting, disconnecting, rationing tools, and babysitting integrations just to keep the agent from hallucinating.

The human contrast#

Connection hell exists because we designed agents around a model no human would ever tolerate.

Think about how you work as a human being.

You do not load every tool that exists on earth into your mind upfront. You do not walk around with the API schemas of Stripe, Jira, Figma, GitHub, and Postgres permanently occupying your working memory.

When you need to get work done, you simply browse the internet. You go to the service, you authenticate—usually clicking a single button—you do the work, and you finish the task. You discover what you need at the moment of use, prove who you are, and move on.

Why on earth are we forcing our AI agents to pre-connect to the entire world before they can take a single step?

Identity over connection#

The assumption underneath connection hell is: for an agent to be autonomous, it must have every tool hardwired into its memory in advance.

It doesn't.

True autonomy does not come from pre-connecting dozens of servers. True autonomy comes from giving your agent an identity so it can go to any service and authenticate itself.

Not a proxy. Not a permissions system. Not another server to babysit.

One job: Sign in with AgentOnboard for Agents.

You go to agentonboard.xyz/dashboard, create your API key once, and run:

aon save <key>

The API key stays securely on your local disk. Your agent never sees it.

Now, when your agent needs to interact with notes.com, it doesn't need an MCP server pre-installed. It doesn't need 10,000 tokens of schemas clogging its prompt.

It reads https://notes.com/auth.md (a tiny 200-token file that describes the endpoints) and runs aon token get notes.com. It receives an asymmetric, five-minute token scoped strictly to that domain.

The API verifies it locally off a cached public key in under one millisecond:

const result = await verifyAgentToken(authHeader, { domain: "notes.com" });
// { ok: true, email: "user@example.com" }

The agent makes a standard HTTPS call, completes the task, and moves to the next job.

That is Sign in with AgentOnboard for Agents: discovery and identity at the moment of use.

What we refuse to do#

We do not manage permissions. We prove who the agent is acting for; whether they can delete a database or only read a document stays in your database where your business logic lives.

We do not route traffic. Requests travel directly between the agent and the API; our servers never see your payloads, and when our site is down, your verification still succeeds locally.

If you run an agent — save your key once and delete the connection toggles. Let your agent navigate the web the way you do: visit, authenticate, do the work, and leave.

If you run an API — host one auth.md file and verify tokens with three lines of @agentonboard/sdk.

No context bloat. No connection hell. An agent that simply goes to any service, authenticates itself, and gets the work done.

Just Sign in with AgentOnboard for Agents.

The docs carry the contract. This post was the why.