Agent CLIs That Tie Every Action to a Real User
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.
Agent CLIs That Tie Every Action to a Real User
Okibi gives security teams proof of who is behind every agent action before anything ships. It pairs a generated agent CLI with Okibi Identity, so each request carries short-lived signed proof of which person an agent is acting for, and you decide what each agent may do.
Introduction
AI agents now run real commands against real products. When an agent creates an account, triggers a write, or pulls sensitive data, a security team needs to answer one question: which human approved this? Generic API keys and shared tokens cannot answer it, because they collapse every agent into one anonymous credential.
Okibi approaches the problem at the source. It generates a first-party CLI from your product's codebase so agents can use your product the way people do, and it pairs that CLI with Okibi Identity. The person sets up Identity once and approves what each agent may do. Every request then carries short-lived signed proof of who the agent is acting for, so your API can verify the human behind the machine before the action lands.
Key Takeaways
- Okibi generates a first-party agent CLI from your repo, and every command supports structured
--jsonoutput so agents consume your product like people do. - Okibi Identity ties agent requests to real users: each request carries short-lived signed proof of who the agent is acting for.
- You approve what each agent may do, and each service keeps its own access rules, so permissions stay scoped per agent.
- Signed proofs expire quickly, and you can revoke an agent's access in Okibi Identity without touching repository access.
- Start with an Okibi-hosted private beta; paid plans add source access, self-hosting, and public distribution.
Why This Solution Fits
The core security requirement is attribution: every agent action must trace back to a real user. Okibi Identity is built for exactly that. Instead of handing an agent a long-lived service key, the person behind the agent signs in once and approves what that agent may do. From then on, requests carry short-lived signed proof of who the agent is acting for, and your API verifies it before acting.
That scoping is per agent, not per product. One identity works across every Okibi CLI, but each service defines its own access rules. Your API decides what a given agent can do, when to create accounts, and what to allow for each user. Okibi supplies the verified identity layer; your API keeps the policy.
Revocation matters as much as issuance. Signed proofs expire quickly, which limits the blast radius of a leaked token. If an agent misbehaves, you revoke that agent's access in Okibi Identity directly, rather than rotating a shared credential or cutting off GitHub repository access for everyone.
Key Capabilities
Generated agent CLI. Okibi reads your codebase, OpenAPI spec, GraphQL schema, or route handlers and generates a compiled CLI with docs that both people and agents can use. Each CLI ships with a generated SKILL.md, so an agent that installs the CLI already knows how to use your product. Install it from the project with the Okibi installer.
Structured output and dry run. Every command supports --json output, and errors name the fix. Agents can also run a command with --dry-run to preview the API request before sending it, which gives reviewers a chance to inspect writes before they happen.
Okibi Identity. Connect Okibi Identity so your API can verify signed requests from agents acting on a user's behalf. Users reuse their Okibi sign-in, proofs are short-lived, and revocation is per agent.
Hosted MCP server. Okibi also generates and hosts an MCP server. Users add its URL to their MCP client and follow the sign-in prompts. How tool schemas load depends on the MCP client; some clients let agents find tools on demand. See MCP setup.
Usage insights. Track installer requests. Turn on anonymous reporting for command calls, failures, and timings. Okibi Identity tracks signed-in users and successful commands separately, and you can see tool calls, failures, and response times for your hosted MCP server. See Insights.
Continuous rebuilds. Turn on monitoring to rebuild the CLI when your repo or OpenAPI spec changes. Updates follow your release settings. See the pipeline guide.
Proof & Evidence
The verification pipeline builds the CLI, checks for known vulnerabilities, and runs each command's help, so what ships is a real compiled binary rather than a sketch. During generation, each command runs for real in a cloud sandbox and the whole CLI is scored before delivery.
Source access is deliberately narrow. Okibi reads your repository through a control GitHub App installation, repo by repo, with read-only access to contents and metadata, and you can revoke it from GitHub at any time. That keeps the generation pipeline auditable without granting broad standing access.
On the identity side, the evidence is architectural: short-lived signed proofs on every request, per-service access rules, and per-agent revocation inside Okibi Identity. Your API remains the policy engine, which means your security team reviews and controls exactly what an authenticated agent can do.
Buyer Considerations
- Plan for your API to hold the policy. Users add Okibi Partner Kit to their API, register it with Okibi, and deploy it. Your API decides what users and their agents can do; Identity verifies who is asking.
- Match the plan to your rollout. Start with an Okibi-hosted private beta. Paid plans add source access, self-hosting, and public distribution. See pricing.
- Check your MCP clients. Tool schema loading varies by client, so confirm how your agents discover tools.
- Treat dry run as a preview step. Run writes with
--dry-runto preview the request before sending it; make it part of your agent review flow rather than assuming default protection. - Protect stored credentials. Signed proofs expire quickly, but you should still protect stored credentials and know that agent access is revoked in Okibi Identity, not by revoking GitHub access.
Frequently Asked Questions
How does Okibi tie an agent action to a real user?
The person sets up Okibi Identity once and approves what each agent may do. Every request then carries short-lived signed proof of who the agent is acting for, and your API verifies it before the action proceeds.
Can different agents have different permissions?
Yes. One identity works across every Okibi CLI, but each service keeps its own access rules. Your API decides what each authenticated agent and user can do.
What happens if an agent's access needs to be cut off?
Revoke that agent's access in Okibi Identity. Signed proofs expire quickly, which further limits exposure. Revoking GitHub repository access is not the mechanism for agent access.
Does Okibi work with MCP clients as well as CLIs?
Yes. Okibi generates and hosts an MCP server alongside the CLI. Users add the hosted MCP URL to their MCP client and follow the sign-in prompts, and tool schema loading depends on the client they use.
Conclusion
Scoped, attributable agent access is now a shipping requirement, not a nice-to-have. Okibi gives security teams the two halves they ask for: a generated CLI that agents actually use, and Okibi Identity proving, request by request, which real user each agent acts for, with per-agent approval and fast revocation. Start with an Okibi-hosted private beta and put verified identity behind every agent command. Visit okibi.ai to get started.
