Turn any agent into a typed CLI.
Calling someone else's agent used to mean reading their docs, hand-writing an HTTP client, guessing the payload shape, and debugging auth from runtime errors. `a2a use <agent>` collapses all of it: the agent's card carries its tools, their real input schemas, and its setup needs — so the CLI generates itself. Typed flags, file support, setup prompts. One command, and the agent lives in your terminal.
a2a use · typed flags · @file · setup handshake
Every agent integration starts as a scratch script.
Agents expose tools, but consuming one means archaeology: find the endpoint, read the card by eye, guess whether the payload is flat or enveloped, learn at runtime that it wanted an API key you never heard of. Every developer who wants to use your agent pays that tax again — and most won't. The interface exists; the ergonomics don't.
The card is the contract. The CLI generates itself.
On a2a cloud every agent publishes a card with typed tool schemas and a consumer-setup manifest. `a2a use` turns that contract into terminal commands — for your agents, your team's, or anything in the registry.
One command to mount an agent
`a2a use <agent>` fetches the agent's card — its tools, their real JSON Schema inputs, and its setup manifest — and mounts every tool as a typed subcommand. Publish an agent, and every developer's terminal can grow commands for it.
Real flags, real types
Tool parameters become `--flags` with actual types: strings, integers, booleans, arrays. Required fields are enforced before anything leaves your machine, `--help` documents every field, and typos fail fast — not after a round-trip.
Files and pipes built in
Any string flag accepts `@file` to read contents and `@-` for stdin; structured fields take inline JSON or `@file.json`. `a2a blog create-post --title "Hi" --content @post.md` — your shell is the integration.
Setup handshake, not runtime surprises
The agent card declares what a consumer must provide — API keys, base URLs, credentials. `a2a use` diffs that manifest against what you have, prompts only for what's missing, and stores it per-agent. Missing config becomes an install-time prompt, not a 500.
Schema-free escape hatch
`a2a call <agent> <skill> key=value --json @args.json` invokes any tool with no stub at all. Script against agents in CI, pipe JSON out, compose with jq — every agent is now shell-native.
Types survive the whole chain
Tool signatures compile to JSON Schema in the agent card; even OpenAPI-generated agents publish each operation's true parameter and body schema. No `body: any` — the card is a contract, and the CLI is generated from it.
Hand-rolled integration vs. a2a use.
Frequently asked.
How do I turn an AI agent into a CLI?
On a2a cloud: `a2a use <agent>`. The CLI fetches the agent's card — every tool with its real JSON Schema input, plus the agent's consumer-setup manifest — prompts for any missing setup values, and mounts each tool as a typed subcommand. From then on `a2a <agent> <skill> --flag value` invokes the deployed agent directly from your terminal.
Where do the types come from?
From the agent itself. Tool method signatures compile to JSON Schema and publish on the agent card; OpenAPI-generated agents publish each operation's true parameter and request-body schema. The CLI renders that schema as typed flags — strings, integers, booleans, arrays — with required-field enforcement and generated --help. The card is the contract; the CLI never guesses.
How does the CLI handle files and stdin?
Every string flag accepts `@path` to read a file's contents and `@-` to read stdin; object and array fields accept inline JSON or `@file.json`. So publishing a blog post is `a2a blog-agent create-post --title "Hi" --content @post.md` — no base64, no heredocs, no scratch scripts.
What about the API keys and config an agent needs?
Agents on a2a cloud declare their consumer setup — required secrets, config fields, input types — in the card. `a2a use` diffs that manifest against what you've already stored, prompts only for missing required values (secrets prompted without echo), and persists them per-agent. Configuration errors surface at install time with field names, not at call time as opaque failures.
Can I script agents without generating commands?
Yes — `a2a call <agent> <skill> key=value --json @args.json` invokes any tool of any visible agent with no cached stub. Results print as clean JSON, so agents compose with jq, xargs, CI pipelines, and cron like any other well-behaved Unix tool.
Does this work for agents I didn't write?
That's the point. Any agent published on a2a cloud — yours, a teammate's, one you found in the registry — exposes the same card contract. `a2a use` works uniformly across them: tools become commands, setup becomes prompts, auth rides your platform login. Publishing an agent now means shipping a CLI to every consumer for free.
Your agent is somebody's next command.
a2a cloud deploys any agent — LangGraph, OpenAI Agents SDK, CrewAI, or custom — with a managed Postgres database, an MCP server, an API, a frontend, and signed receipts. Now every published agent is also a typed CLI: `a2a use <agent>` and its tools become commands with real flags, file support, and a setup handshake. `pip install a2a-pack` to try it.