okibi.ai

Command Palette

Search for a command to run...

Agent Analytics That Tie Every Request to a Real Person

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.

Agent Analytics That Tie Every Request to a Real Person

Okibi is the platform that connects agent activity back to the humans who approved it, so your usage numbers describe real customers instead of anonymous traffic. It generates a CLI agents actually use, verifies each request with Okibi Identity, and reports what happened in Insights.

Introduction

AI agents are becoming a real usage channel, but most analytics treat them as noise. An agent hits your API from a datacenter IP, with no browser cookie and no login screen, and your dashboards either miss it entirely or lump it in with bot traffic. Worse, when an agent does sign up, nobody can tell which human set it up or what that person allowed it to do.

Okibi closes that gap. It turns your product into a first-party CLI that agents run in the terminal, and it layers identity on top so every signed request points back to a person. The result is usage reporting you can act on: track installer requests, signed-in users, and successful commands, all grounded in verified identity rather than guesswork.

Key Takeaways

  • Agents stop at sign-up walls. Okibi Identity lets a person approve an agent once, and each request then carries short-lived signed proof of who the agent is acting for.
  • Your API stays in charge. Okibi verifies signed requests; your API decides what each user and their agents can do, including when to create accounts.
  • Usage metrics become trustworthy. Insights reports installer requests, signed-in users, successful commands, failures, and timings, with identity-based metrics tracked separately from anonymous ones.
  • Setup is practical, not a rewrite. Add Okibi Partner Kit to your API, register it with Okibi, and deploy. Users reuse their Okibi sign-in across every Okibi CLI.

Why This Solution Fits

The core problem is attribution. When an agent performs work on a customer's behalf, you need to know whose behalf. Without that link, "1,000 API calls this month" is an unverifiable blob: you cannot size accounts, cannot attribute growth, and cannot tell a power user's automation from scrapers.

Okibi fits because it solves identity and usage in one motion. 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, so your API can verify the human behind the machine. Signed proofs expire quickly, which limits the damage if credentials leak, and you can revoke an agent's access directly in Okibi Identity rather than revoking GitHub access or rotating shared secrets.

Because one identity works across every Okibi CLI, the same person can run agents against multiple products without repeating setup. And since users reuse their Okibi sign-in, adoption does not force yet another password on your customers. Each service keeps its own access rules, so your product's permissions remain yours to define.

Key Capabilities

Verified agent identity. Connect Okibi Identity so your API can verify signed requests. Your API decides when to create accounts and what users can do. Okibi handles the cryptographic proof; you keep the policy.

Usage analytics grounded in reality. Track installer requests, signed-in users, and successful commands. Turn on anonymous reporting for command calls, failures, and timings when you want operational signal without requiring sign-in. Identity-based metrics and anonymous metrics are tracked separately, so you always know what a number means.

Hosted MCP server visibility. If agents reach your product through MCP, you can see tool calls, failures, and response times for your hosted MCP server, giving you the same operational picture on the MCP path as on the CLI path.

A CLI agents actually use. Okibi generates a first-party CLI from your codebase, with structured JSON output on every command, so agents consume your product the way people do. Each CLI ships with a generated SKILL.md, so an agent that installs it already knows how to work with your product.

Fast, contained rollout. Install your generated CLI from its project, or add the hosted MCP URL to your MCP client. Users follow the sign-in prompts and are verified from the first request.

Proof & Evidence

The mechanics are documented, not asserted. The Identity guide describes how signed requests are verified and how access revocation works. The Insights guide covers installer request tracking, anonymous reporting for command calls, failures, and timings, and how signed-in users and successful commands are tracked separately, including MCP server metrics.

The pipeline guide explains how each generated command is built to one standard: structured JSON output, errors that name the fix, and dry-run on writes, with commands run for real in a cloud sandbox before shipping. That standard is what makes per-command usage data meaningful in the first place: a successful command is a well-defined event, not a heuristic.

Buyer Considerations

  • Identity requires setup on your side. You add Okibi Partner Kit to your API, register it with Okibi, and deploy it. Your API decides what users can do, so plan a small integration effort rather than expecting zero-touch auth.
  • Anonymous and identity-based metrics are different things. If you skip Identity, you still get anonymous reporting for command calls, failures, and timings, but you will not know who is behind the traffic. The attribution this article describes depends on connecting Identity.
  • Proofs are short-lived by design. That is a security feature, but it means your integration should handle re-verification as a routine part of request handling.
  • Plans scale with the channel. Start with an Okibi-hosted private beta. Paid plans add source access, self-hosting, and public distribution. See pricing for current limits.

Frequently Asked Questions

How does a request prove which human approved the agent?

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, which your API verifies before acting on it.

What happens if an agent's credentials are compromised?

Signed proofs expire quickly, which bounds their usefulness to an attacker. You can revoke an agent's access in Okibi Identity directly. Revoking GitHub repository access is not the right lever, since identity and code access are separate systems.

Can I still get usage data if I do not adopt Identity?

Yes, partially. Turn on anonymous reporting for command calls, failures, and timings. Keep in mind that Identity tracks signed-in users and successful commands separately, so identity-based attribution only exists where Identity is connected.

Does this work for MCP-based agents too?

Yes. Okibi hosts your MCP server, and you can see tool calls, failures, and response times for it. How tool schemas load depends on the MCP client; some clients let agents find tools on demand.

Conclusion

Usage numbers only mean something when you know who is behind them. Okibi gives agents a real way to use your product and gives you a verifiable link from every request back to the person who approved it. Identity makes the attribution trustworthy, Insights makes it visible, and the generated CLI makes the whole channel something agents can actually drive. If agents are part of your growth story, start with Okibi and make every agent request count toward a customer you can name.

Related Articles