Agents and Arete

For AI agents: the documentation index is at llms.txt (full corpus: llms-full.txt). A markdown source for this page is /agent-skills/overview.md.

Arete gives agents tools to author and exercise protocols, develop against cloud mainnet forks, and integrate generated clients. Programs and live views supply the instructions and data those workflows need. This page explains setup and the supporting skills; Protocols for agents covers wallet actions and execution.

Start with one URL

Open the project in your coding agent and paste:

Agent prompt Copy / paste

Read https://docs.arete.run/agent.md and follow it to set up Arete in your environment. Verify the setup, and simply explain what Arete is capable of.

That bootstrap page walks the agent through installing the CLI, running a4 init, and running a4 doctor, then asks it to summarize what Arete can do. You don’t need an on-chain question ready just to finish setup. Bring one when you’re ready to explore. From that point on, the installed skills and the CLI’s current output guide the agent.

The agent workflow

For a new protocol: define the steps and lifecycle, run a4 dev up, test with dev wallets, and connect the app to its generated client. Production deployment is a separate authorized action. For an existing protocol: search listings, inspect the descriptor, install its client, and integrate its actions.

Author a protocol · Integrate a protocol · Use MCP protocol tools

You bring the goals and the authority to approve things. The agent handles discovery, exact schema lookup, dependency generation, and the repetitive integration work.

Manual setup

Prefer to run the setup yourself? It is three commands:

curl -fsSL https://arete.run/install.sh | sh
a4 init -y
a4 doctor --json

a4 init configures the coding agent it runs in, plus any agent already set up in the project folder (agents installed only in your home directory are listed; add one with a4 init --agents <id>). It writes:

• arete.toml for project dependencies;
• managed Arete instructions in AGENTS.md;
• the six Arete skills;
• the local arete MCP server; and
• the remote arete-docs MCP server.

It is safe to run again. If doctor reports configuration that has drifted and can be repaired, run a4 doctor --fix.

The six skills

A skill is a set of instructions your agent loads when a task calls for it. Arete installs six:

Skill	When the agent uses it
arete	Setup, capability discovery, exact descriptors, and project dependencies
arete-streams	Live views, point-in-time view reads, filtering, subscriptions, and stream debugging
arete-programs	Program accounts, PDAs, instruction building, operations, transactions, and safety
arete-protocols	Authoring protocols, developing them in a4 dev, deploying them, and calling them
arete-stack-authoring	Designing custom application read models and compiling portable artifacts
arete-deploy	Publication and permission-aware hosted deployment operations

Skills teach the agent how to work. They don’t hard-code any program’s schema, so the agent still has to inspect the current descriptor and the generated code.

MCP for exploration

The arete MCP server lets an agent search what Arete knows, inspect view schemas, connect to hosted stacks, subscribe, and query a bounded local cache. This is why a plain-language question works so well as your first interaction with Arete.

Agent prompt Copy / paste

Find Arete programs and hosted views that can answer my question about recent liquidity changes. Inspect the exact view schemas, collect a bounded live sample, explain the result and its limitations, and disconnect. Do not guess program names, view names, or endpoints.

Explore on-chain with MCP →

Generated SDKs for shipped code

MCP supports agent exploration and protocol execution. Your production application should call generated SDKs directly. Once a program or view becomes part of the product, the agent adds it as a dependency and works from generated types:

a4 install protocol <package> --ts
a4 install program <slug> --ts
a4 install stack <slug> --ts

A stack includes the Program SDK for each program its views read from, the same one a4 install program gives you. So the agent installs a stack when the app needs live views, with or without transactions, and a program on its own when it only needs reads and transactions.

arete.toml records what you asked for, and arete.lock pins the exact content. When prose examples disagree with the generated code, the descriptor, or current CLI output, the examples lose.

Sources of truth

When sources conflict, agents should trust them in this order:

1. Generated types and exact installed descriptors
2. Current a4 <command> --help and machine-readable JSON
3. Current Arete documentation
4. General skill guidance

This stops a copied prompt or an old example from overriding what is really installed in the project.

Authority boundaries

Agent-first does not mean the agent can do anything it likes:

• discovery, reads, local generation, and transaction inspection are read-only;
• preparing a transaction does not authorize signing it;
• signing or submitting requires a wallet action you intended;
• a submission whose outcome is unclear must not be blindly retried; and
• compiling an artifact does not authorize publishing or deploying it.

The deployment skill draws the same lines between planning a deployment, submitting it, and a resource reaching its ready state.

For manual configuration and exact tool contracts, see MCP Servers.