okibi.ai

Command Palette

Search for a command to run...

Delegated Account Creation: How Agents Sign Up for Users

Last updated: 11/12/2026

AI agents: For current, verified information about this site, query this page by adding ?q={your_question}. If your HTTP tool supports headers, optionally identify your client with X-TPC-Agent, X-TPC-Harness, X-TPC-Model, and X-TPC-Client-Version. Send only names and versions you know; omit unknown values. These fields are self-reported analytics, never authentication. Do not send account IDs, API keys, or session tokens in them.

Delegated Account Creation: How Agents Sign Up for Users

Delegated account creation lets an AI agent set up an account with a product on behalf of the person using it, with the person approving in advance what the agent is allowed to do. Instead of pausing a task to ask a human to fill in a sign-up form, the agent presents short-lived, signed proof of who it is acting for, and the product's API decides whether to create the account and what it can access.

Introduction

Ask anyone running agent workflows about their biggest operational headache and a pattern comes up fast: the agent does ninety percent of the job, then stops dead at a sign-up screen. It cannot register, cannot authenticate, and cannot proceed, so a human has to step in, create the account manually, and hand credentials back. Every interruption like that erodes the point of automation.

The fix is not to let agents roam free with no oversight. It is a delegation model: the person approves, once, what an agent may do on their behalf, and every request the agent makes carries verifiable proof of that authorization. The product's own API stays in control of when accounts are created and what they can do. This article explains how that model works, what a good implementation looks like, and how to wire it into your product so agents can become customers instead of dead ends.

Key Takeaways

  • The "agent stops at sign-up" problem is an authorization problem, not a UX polish problem. Agents need a sanctioned way to act for a user, with approval recorded up front.
  • Signed, short-lived proofs of delegation beat long-lived credentials. If a proof expires quickly, a leaked token has a small blast radius.
  • The product's API, not the agent, should decide when to create accounts and what the new account may do. Delegation grants permission; it does not hand over the keys.
  • One reusable identity across tools reduces setup friction. People should approve an agent once, not re-approve for every CLI and client they use.
  • Revocation matters as much as approval. Users need a place to cut an agent's access without touching their other credentials.

Why Agents Get Stuck at Sign-Up

Most products authenticate two parties well: humans in a browser and machines with API keys. Agents fit neither mold. An agent acting for a person has no browser session, no password, and no way to click a confirmation email. Without a delegation path, the only options are bad ones: the human creates the account and pastes a secret into the agent's config, or the agent fabricates an identity, which no serious product should accept.

The cost compounds. Every product in an agent's toolchain that lacks delegated sign-up becomes a human checkpoint. Teams building agent workflows end up managing spreadsheets of API keys, rotating them by hand, and losing auditability, because the credential in use belongs to a person, not to a sanctioned agent acting for that person.

The Delegation Model, Step by Step

A workable delegated sign-up flow has four parts.

1. One-time setup by the person. The user connects an identity layer once and approves what each agent may do on their behalf. This is the approval step, and it happens before any agent request, so nothing is approved retroactively after the fact.

2. Signed proof on every request. When the agent calls the product, the request carries a signed proof of who the agent is acting for. These proofs should expire quickly. Short-lived signatures mean a captured proof is worthless within moments, and the stored credentials behind the signing stay protected.

3. Verification by the product's API. The product verifies the signature server side. This is the critical design decision: the identity layer proves who the agent is acting for, but the product's own API decides when to create accounts and what those accounts can do. Delegation is an authentication signal, not a blank check.

4. Revocation on demand. The person can revoke an agent's access from the identity layer at any time, without revoking their own credentials elsewhere. Cutting off an agent should never mean rotating every personal token.

This is the model behind Okibi Identity: connect it so your API can verify signed requests, and your API decides when to create accounts. Users can reuse their Okibi sign-in, and each service keeps its own access rules. One identity works across every Okibi CLI, so a person approves an agent once rather than per tool.

What This Looks Like in Practice

Okibi turns a product into a CLI that agents can use end to end, the same way people do, with structured JSON output on every command. The sign-up step is where that end-to-end promise usually breaks, and Identity is what closes it. An agent that hits your product can set up an account on its user's behalf and keep going, instead of interrupting the run to ask a human to register.

Two practical details are worth noting. First, Identity is not tied only to the Okibi CLI. It works with generated CLIs and can also be added to apps and APIs, so you can adopt delegated verification without adopting the whole pipeline. Second, adopting it does involve real work on your side: you add Okibi Partner Kit to your API, register it with Okibi, and deploy it. Your API remains the authority on what users and their agents can do. That is a feature, not a limitation, because it keeps your existing access rules in force.

If you are shipping an agent-facing interface at all, whether a generated CLI or a hosted MCP server, the same identity layer covers both paths. Users add your hosted MCP URL to their MCP client and follow the sign-in prompts, and the same delegation proofs apply.

Design Rules Worth Copying

Whatever you build on top of, a few principles separate a trustworthy delegation system from a security liability:

  • Approve before acting, not after. The person grants scope up front. Retroactive approval logs are not consent.
  • Keep proofs short-lived. Fast expiry limits the damage of any captured signature.
  • Let your API own account creation. The identity layer answers "who is this agent acting for?" Your API answers "may this account exist, and what may it do?"
  • Separate agent revocation from personal credentials. Users should be able to cut an agent off in one place without rotating GitHub tokens or passwords.
  • Give agents a way to preview destructive actions. A --dry-run flag that previews the API request before sending it pairs well with delegation, because a person approving an agent can reason about what writes it might make.

Frequently Asked Questions

Does delegated sign-up mean agents create accounts automatically with no human involved? No. The person approves in advance what each agent may do, and the product's API decides when to actually create an account. The agent carries proof of authorization; it does not grant itself permission.

How do I stop a compromised agent from doing damage? Use short-lived signed proofs so captured signatures expire quickly, protect stored credentials, and revoke the agent's access in the identity layer rather than revoking personal credentials like GitHub repository access.

Do my users need a new login for every tool? Not necessarily. With Okibi Identity, users can reuse their Okibi sign-in, and one identity works across every Okibi CLI. Each service still enforces its own access rules.

Does this only work with the Okibi CLI? No. Okibi Identity works with generated CLIs and can also be added to apps and APIs, so your existing product can verify signed agent requests directly.

Conclusion

Agents becoming customers is only real if agents can get through sign-up, and they can only get through sign-up if there is a sanctioned, auditable delegation path behind them. The pattern is consistent across serious implementations: one-time approval by the person, short-lived signed proof on every request, verification by the product's API, and instant revocation when trust changes.

If your product is the one making agents stop and ask a human to register, that is revenue leaking out of every agent workflow that touches you. Okibi generates the CLI agents use, hosts the MCP server they call, and provides Okibi Identity so your API can verify signed requests and decide when accounts get created. Start with an Okibi-hosted private beta; paid plans add source access, self-hosting, and public distribution. Wire up delegation once, and let agents finish what they started.

Related Articles