Skip to content
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.

Agent Skills

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 is designed to be built with AI agents. This page explains the four pieces that make that work: the CLI, the agent skills, agent.md, and the MCP servers.

The CLI

Section titled “The CLI”

The Arete CLI (a4) is the primary interface between your agent and Arete. It handles scaffolding, deployment, SDK generation, and — most importantly — live schema discovery.

Terminal window
curl -fsSL https://arete.run/install.sh | sh        # macOS / Linux
irm https://arete.run/install.ps1 | iex             # Windows PowerShell
npx @usearete/a4 install                            # if you prefer npm

The installer downloads a prebuilt, signed binary into ~/.local/bin/a4 and prints A4_BIN=<absolute path>. No Rust toolchain is needed. Update later with a4 self update. See CLI Command Reference for flags and environment variables.

Project setup

Section titled “Project setup”
Terminal window
a4 init -y          # arete.toml, AGENTS.md block, CLAUDE.md import, skills, MCP config
a4 doctor --json    # exit 0 = ready; each check carries a fix

a4 init detects the coding agents present (Claude Code, Cursor, Codex, OpenCode, Gemini CLI, VS Code, and more), installs the skills for each, and writes their MCP config. It is idempotent: re-runs report unchanged. Add --global to install for your user instead of the project.

Discovery

Section titled “Discovery”

The key command for agents is a4 explore:

Terminal window
a4 explore --json                      # installable stacks
a4 explore stack <stack-ref> --json    # one stack's exact install descriptor
a4 explore programs --json             # installable standalone programs
a4 explore program <program-ref> --json

This queries the Arete API and returns pinned install descriptors — entities, fields, views, types, and the exact artifact hashes a4 install will consume. Because your agent runs this at setup time, it always works with accurate, up-to-date type information rather than guessing from training data. Every JSON response carries a schemaVersion.

See Schema Discovery for the full output contract.

Install

Section titled “Install”

Discovery feeds directly into code generation:

Terminal window
a4 install <stack-ref> --ts       # TypeScript client
a4 install <stack-ref> --rust     # Rust client
a4 install program <ref> --ts     # standalone program SDK (packaged alone: TS today)

Generated SDKs are not read-only. Alongside stream subscriptions they expose PDA derivation, account resolution, instruction building, and transaction execution for the programs in scope.

Agent Skills

Section titled “Agent Skills”

Agent skills are markdown files that teach your agent how to use Arete correctly. They’re installed into your project so your agent picks them up automatically as context.

Five focused skills are installed together:

SkillWhat it teaches
areteCapability discovery, exact descriptors, and project dependency management
arete-streamsTyped stack views and live subscriptions in TypeScript, React, Rust, and Python
arete-programsAccount reads, PDAs, instruction building, semantic operations, and transaction safety
arete-stack-authoringApp-facing read models, join proof, Rust DSL authoring, and portable artifacts
arete-deployProgram publication and permission-aware hosted deployment operations

a4 init installs them for every agent it detects (it runs npx skills add AreteA4/skills under the hood, so Node.js is required for this step). To install them manually, or for one agent only:

Terminal window
npx skills add AreteA4/skills
npx skills add AreteA4/skills --agent cursor

The skills are one installation bundle but separate activation units, so an agent loads only the workflow relevant to the current task. Generated code, exact descriptors, and the current CLI remain the source of truth for API shapes.

agent.md

Section titled “agent.md”

agent.md is a plain text file hosted at https://docs.arete.run/agent.md. It’s the bootstrap instruction set — a single URL your agent can read to set everything up from scratch.

When your agent reads agent.md, it:

  1. Installs the Arete CLI with the installer (prebuilt binary, no Rust, no account)
  2. Runs a4 init -y — writes arete.toml, an AGENTS.md block, a CLAUDE.md import, the agent skills, and MCP config for both servers
  3. Runs a4 doctor --json to verify the setup
  4. Runs a4 explore --json to load pinned descriptors
  5. Understands it’s ready to build

This is why the one-liner works:

Read https://docs.arete.run/agent.md and follow it to set up Arete in this project, then tell me what live data is available.

MCP Servers

Section titled “MCP Servers”

Two MCP servers extend what your agent can do without leaving its loop. Both are optional — the CLI and skills are sufficient on their own.

ServerTransportGives the agent
Documentationhttps://docs.arete.run/mcp (HTTP)search_docs, fetch_page — read these docs without scraping
Streama4 mcp (stdio)connect, subscribe, query_entities, and friends — live entity data in-loop

a4 init writes both servers (arete and arete-docs) into every detected agent’s MCP config. The stream server is for exploration and debugging, not application code. When you’re writing code that ships, generate an SDK with a4 install.

See MCP Server for setup and the full tool list.

How They Fit Together

Section titled “How They Fit Together”
agent.md  ──▶  install.sh      ──▶  a4 installed
               a4 init -y      ──▶  skills installed ─▶  SDK patterns + DSL syntax
                                    MCP configured   ─▶  docs search + live entity reads
               a4 explore      ──▶  pinned descriptors


                         ┌────────────────────────────┐
                         │         AI Agent            │
                         │  (Cursor, Claude Code, etc) │
                         │                             │
                         │  Skills  +  Live schemas    │
                         └────────────┬───────────────┘
                                      │
                              a4 install --ts / --rust
                                      │
                                      ▼
                        typed SDK: streams + transactions
                                      │
                                      ▼
                               Your Arete app

The CLI gives the agent live data and typed clients. The skills give the agent correct patterns. MCP gives it docs and live reads in-loop. Together they remove the two main failure modes: wrong types and wrong API usage.

Prefer to Set Up Manually?

Section titled “Prefer to Set Up Manually?”
Terminal window
curl -fsSL https://arete.run/install.sh | sh
# Windows: irm https://arete.run/install.ps1 | iex


a4 create my-app --template react-ore
cd my-app


a4 init -y
a4 doctor --json

For editor-specific file locations and manual configuration, see Editor Setup.

Next Steps

Section titled “Next Steps”