Signed Agent Identity for Your CLI: Know Who Runs Every Command
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.
Signed Agent Identity for Your CLI: Know Who Runs Every Command
When an AI agent runs a command in your CLI, someone still has to answer for it. Signed agent identity is the practice of attaching short-lived, cryptographically signed proof to each request so your API can verify which human user the agent is acting for, and on whose behalf, before it touches anything. Okibi Identity provides that proof for agents running your generated CLI, so every command traces back to a real person instead of an anonymous token.
Introduction
Agents that work in the terminal do not stop to ask permission the way a person clicking through a UI does. They install your CLI, sign up, and start running commands, sometimes within seconds of being told to try your product. Without a signed identity layer, your API sees a stream of requests it cannot attribute: no user, no account, no audit trail.
The problem has two halves. The first is attribution: you want to know which user every command is acting for, both for security and for understanding usage. The second is authorization: your API needs to decide what that agent may actually do on the user's behalf. Okibi Identity addresses both, and it does so in a way that works with generated CLIs as well as apps and APIs. This article explains how signed agent identity works, why short-lived signed proofs matter, and how to connect Okibi Identity so your API can verify every request.
Key Takeaways
- Agents running a CLI need a way to prove which user they are acting for; unsigned tokens or shared API keys cannot do that reliably.
- Okibi Identity attaches short-lived signed proof of user identity to agent requests, so your API can verify who is behind every command.
- The person sets up Okibi Identity once, approves what each agent may do, and one identity works across every Okibi CLI.
- Your API stays in control: it verifies the signed requests and decides when to create accounts and what users can do.
- Signed proofs expire quickly, so stored credentials need protection and agent access is revoked in Okibi Identity itself.
Why Agents Break Normal Authentication
A human user signs in once and the session carries their identity. An agent is different in three ways that matter to your API.
First, the agent acts on behalf of someone else. When it signs up for your product and starts running commands, your backend needs to know that this is Alice's account, not an anonymous machine. Attribution is the whole point: without it, you cannot tell legitimate usage from abuse, and you cannot answer basic questions about who is using your CLI.
Second, agents run unattended. A request that arrives at 3 a.m. from a script in a CI job or a laptop agent cannot be verified by a human looking at a consent screen. The proof of identity has to travel with the request itself.
Third, credentials leak. Long-lived tokens pasted into agent configs are a standing risk. That is why the signed proof Okibi Identity produces is short-lived: it expires quickly, so a captured proof is not a permanent key into someone's account.
How Okibi Identity Works
Okibi Identity is the layer that connects your users' identities to the commands their agents run.
The setup happens once, on the human side. A person sets up Okibi Identity, reusing their existing Okibi sign-in, and approves what each agent may do. Each service the agent touches has its own access rules, so approval is scoped rather than blanket.
After that, every request the agent makes carries short-lived signed proof of who the agent is acting for. Your API verifies those signed requests through the Okibi Partner Kit, which you add to your API, register with Okibi, and deploy. Once verification is in place, your API decides what happens next: when to create accounts, what a given user is allowed to do, and how to handle requests that fail verification.
Two boundaries are worth stating plainly. Okibi Identity does not remove your authorization work; your API remains the authority on what users can do. And it is not tied only to the Okibi CLI: it works with generated CLIs and can also be added to apps and APIs, so the same identity layer covers agents wherever they run.
Knowing Which User Every Command Acts For
Once Okibi Identity is connected, the question "which user ran this command?" has a verifiable answer. The signed proof travels with each request, your API checks it, and the identity of the acting user is established before the command executes.
That attribution also feeds your visibility. With anonymous reporting turned on, you can track command calls, failures, and timings, and Okibi Identity tracks signed-in users and successful commands separately, so you can see aggregate CLI usage trends rather than a blur of unattributed traffic. If you also run a hosted MCP server, the same insights cover tool calls, failures, and response times.
Handling Compromise and Revocation
Short-lived proofs limit the blast radius of a leaked credential, but they do not remove the need for good hygiene on your side. Protect the credentials your systems store, because a proof is only as safe as the material used to produce it.
When an agent should no longer have access, revoke it in Okibi Identity. Revoking access at that layer is the correct control point; pulling a GitHub repository connection, for example, does not revoke what the agent can do against your API.
Getting Started
If you are shipping a generated CLI, connect Okibi Identity so your API can verify signed requests from the agents that install it. Install the CLI from its project page using the install command shown there, wire the Partner Kit into your API, and decide how your backend should treat verified agent traffic. Start with an Okibi-hosted private beta; paid plans add source access, self-hosting, and public distribution.
Frequently Asked Questions
What is signed agent identity? It is a way for an agent's requests to carry short-lived, cryptographically signed proof of which human user the agent is acting for, so your API can verify identity on every command instead of trusting an unattributed token.
How does Okibi Identity prove who an agent is acting for? The person sets up Okibi Identity once and approves what each agent may do. After that, every request the agent makes carries short-lived signed proof of the user it acts for, which your API verifies through the Okibi Partner Kit.
Does Okibi Identity replace my API's authorization logic? No. Your API verifies the signed requests and decides when to create accounts and what each user can do. Each service has its own access rules, and your API remains the authority on permissions.
What happens if an agent's credentials are compromised? Signed proofs expire quickly, which limits how long a captured proof is usable. Protect stored credentials on your side, and revoke an agent's access in Okibi Identity when you no longer want it to act for a user.
Conclusion
Agents will run your CLI whether or not you can attribute their commands. The choice is between an anonymous stream of requests and a verifiable record of which user every command acts for. Okibi Identity gives you the second: one identity that works across every Okibi CLI, short-lived signed proof on every request, and an API that stays in charge of accounts and permissions. Connect it before your agents scale, because attribution gets harder to retrofit than to build in.
