Skip to content

Arete documentation

Agents and Arete

For the complete documentation index optimized for AI agents, see llms.txt or llms-full.txt. A markdown version of this page is available by appending .md to the URL or sending Accept: text/markdown.

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 a sandbox to act from, and the tools to read the chain around it: program reads, live views and the catalog. This page explains setup and the supporting skills; Connect your agent covers pointing an agent at a sandbox.

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.

In a sandbox: read sandbox_status and sandbox_rules, preview each action, run it, and follow refusals’ hints. Around it: discover programs and live views from intent, and read them through MCP or the CLI.

Connect your agent · Actions · Read scope

In private beta, agents can also author and exercise protocols in cloud dev environments and integrate generated clients.

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

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

Terminal window
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.

A skill is a set of instructions your agent loads when a task calls for it. a4 init installs the ones your account’s command groups cover:

SkillGroupWhen the agent uses it
arete-sandboxsandboxesActing from a sandbox wallet: status, rules, preview, invoke, refusals and history
areteregistrySetup, capability discovery, exact descriptors, and project dependencies
arete-programsregistryProgram accounts, PDAs, instruction building, operations, transactions, and safety
arete-streamsstreamsLive views, point-in-time view reads, filtering, subscriptions, and stream debugging
arete-protocolsprotocols, devAuthoring protocols, developing them in a4 dev, deploying them, and calling them
arete-stack-authoringstacksDesigning custom application read models and compiling portable artifacts
arete-deploystacks, protocolsPublication 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.

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 →

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:

Terminal window
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.

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.

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.