---
title: Okibi · Turns products into CLIs and agents into customers
description: Okibi generates a CLI from your product, so agents can use it fully on their own.
canonical: https://okibi.ai/
agent_quickstart: https://okibi.ai/agent.md
---

# Turn your product into a CLI, and agents into customers

Okibi generates a CLI from your product, so agents can use it fully on their own.

[Try it for free](https://okibi.ai/login)

```sh
curl -fsSL https://okibi.ai/install | sh
```

[Agent quickstart](https://okibi.ai/agent.md)

## Product preview

The visual landing page shows a scout-first Okibi session using OpenRouter. Opening Okibi inside the repository starts the scout automatically. It returns a grouped first draft, accepts direction, generates the CLI, and then uses it:

```text
$ curl -fsSL https://okibi.ai/install | sh
$ okibi auth login
$ okibi

Scout OpenRouterTeam/typescript-sdk
first draft · openrouter-cli · 6 groups · 10 commands
chat: send · stream
models: list · get · endpoints
providers: list
credits: balance
generations: stats
keys: list · create

> add a command to delete an API key
✓ added keys delete · 11 commands now

> generate it
✓ generated CLI unpacked into ./openrouter-cli

> write me a haiku about CLIs using kimi-k3
Run | (openrouter chat send --model moonshotai/kimi-k3 --prompt "a haiku about CLIs")
✓ replied · 42 tokens · $0.0005
```

This is an illustrative product preview, not a recorded run. After the terminal story finishes, the visual unlocks Dashboard and Commands views for the generated CLI.

## Try it live

Paste an existing public GitHub repository. Okibi reads the code and drafts a CLI live, with commands you can try in a real terminal. Generate it when the command surface is ready.

## Why a CLI

Agents don’t have a good way to use your product.

```diff
@@ your options @@
- mcp  a few tools can’t do the job, too many and it grabs the wrong one
- api  it builds every call from scratch, and sometimes builds it wrong
+ cli  every command is already built, so it works right every time
```

The best companies are already shipping first-party agent CLIs. Okibi generates yours.

## Generated, then actually run

Okibi drafts your command set, you steer it, and every command it builds gets executed and checked. This is the CLI that comes out. This extended visual uses Replicate:

```sh
$ replicate models search flux
MODEL                            RUNS
black-forest-labs/flux-schnell   688.7M
bytedance/sdxl-lightning-4step   1.0B
google/nano-banana               116.6M

$ replicate models run black-forest-labs/flux-schnell --prompt "a neon banana"
✓ succeeded · out-0.webp · 1.4s

$ replicate predictions get gm3qorzdhgbfurvjtvhg6dckhu --json
{ "status": "succeeded", "metrics": { "predict_time": 1.42 } }
```

## It doesn’t just write a CLI

It makes sure the CLI is right.

- **Research.** Okibi learns what your product is used for and which jobs matter most, then reads every existing tool for it, from competitor CLIs to MCP servers and SDKs.
- **Design.** From that research it designs the command set: match everything those tools do, then add what none of them have. Every candidate is scored, and you keep what you want.
- **Build and verify.** Every command is built to one standard, structured JSON, errors that name the fix, and dry-run on writes. Verification goes far past “it compiles,” each one runs for real in a cloud sandbox and the whole CLI is scored.
- **Ship and update.** A real compiled binary with generated docs that people and agents both use. Whenever your product updates, Okibi mints the changes and maintains your CLI for you.
- **Skilled.** Every CLI ships with a generated skill file. An agent that installs your CLI will already know how to use your product.
- **Identity.** Your CLI comes with Okibi Identity built in. An agent that needs an account sets one up with its user’s identity, and every request carries proof of who it’s acting for.

## Okibi Identity

Even with a CLI, an agent stops at sign-up. It has to interrupt its work, ask its user to go set up an account, and wait. With Okibi Identity it doesn’t. The agent sets up the account on its user’s behalf and keeps going. This is how you will get agents as customers.

- **One sign-in.** The person sets up their Okibi Identity once and approves what each agent may do.
- **Signed proof.** Every request carries short-lived signed proof of who the agent is acting for.
- **Every Okibi CLI.** One identity works across every Okibi CLI, so an agent arrives ready to set up its user’s account with yours.

## Simple pricing

Start free on one repo. Upgrade when your CLI takes off. No credit card required.

### Free — $0

Build and privately test before you launch.

- 1 private beta CLI
- 3 builders / admins
- 5 successful generations / month
- 25 internal testers + 50 beta users
- 1,000 successful commands/month
- Okibi-hosted only
- No source access or self-hosting
- Private beta distribution

### Production — $200/mo or $150/mo billed annually

Put your product in front of agents.

- 1 production CLI included — Then $100/mo per additional CLI
- Unlimited collaborators
- Unlimited fair-use generations
- 500 authenticated agent users/mo included — Then $2 per additional active agent
- 5,000 successful commands/mo included — Then $0.05/extra successful command
- Source access and self-hosting
- Public distribution

### Enterprise — Custom

Minimum annual commitment.

- Everything in Production, plus
- Custom agents + successful-command limits
- SSO, SCIM + advanced roles
- SLA + security review
- Dedicated support

## Questions, answered

### What languages does my repo need to be in?

Any! Okibi reads server code, OpenAPI specs, GraphQL schemas, or plain route handlers.

### Is my code safe?

Okibi reads through a GitHub App installation you control, repo by repo. Access is read-only (contents + metadata) and revocable from GitHub at any time.

### How do agents use my CLI?

Agents work in the terminal, so they run your generated CLI directly: the same commands people do, with structured --json output on every one. Agents use your product the same way people do.

### Can I edit the generated CLI?

Yes. You shape the commands before generation, refine the spec afterwards, and regenerations preserve your choices version to version.

## It starts with one repo

Give agents full access to your product.

[Build your CLI](https://okibi.ai/login)

## Policies

- [Security](https://okibi.ai/security)
- [Privacy](https://okibi.ai/privacy)
- [Terms](https://okibi.ai/terms)
