What is Arete?

For AI agents: the documentation index is at llms.txt (full corpus: llms-full.txt). A markdown source for this page is /getting-started/what-is-arete.md.

To start using Arete, give your coding agent the setup prompt. The rest of this page explains what you can build with it.

Arete is a platform for building and running protocols on Solana. You define what people can do, who may do it, and how each instance progresses. Arete prepares the transactions, tracks the workflow, and generates the interface your application or agent uses.

For example, a token raise might let a creator open a raise, participants contribute, and eligible wallets claim or refund after the outcome is known. Each step uses existing Solana programs. A protocol can compose their instructions without requiring a new on-chain program for the composition. The underlying programs must still enforce the asset rules your product needs.

The protocol is the application workflow

An Arete Protocol defines:

• Steps: actions with typed arguments and instruction templates, or custom handlers when templates are insufficient.
• Guards and authority: checks on a step and the wallet or role that signs.
• Lifecycle: state machines for instances and, when needed, participants.
• Reactions: responses to time, conditions, transitions, or confirmations.
• Data: metadata, named events, and the protocol’s generated live views.

One raise is an instance. A contributor is a participant whose state can differ from the raise’s state. This lets your app ask both “is the raise open?” and “has this wallet already claimed?”

Core concepts →

The development environment is part of the workflow

Start with a4 protocol init, then run a4 dev up. Arete builds the protocol and deploys it privately into your cloud dev environment, a persistent mainnet fork. You can execute steps with test wallets, inspect live activity, change balances, move time forward, and repeat experiments from checkpoints.

Editing the protocol rebuilds and deploys a new release. Its generated client follows the local build, so your app can develop alongside the protocol. Custom handlers can run without review in private dev environments; production handler releases require review.

Build your first protocol →

Applications and agents call the same protocol

An integrator installs a published protocol with a4 install protocol and calls its deployment. There is no need to deploy a copy just to use an available public protocol.

The generated client exposes the protocol’s typed steps, instances, participants, metadata, events, and wallet action discovery. A composed session brings installed dependencies together:

• session.protocols contains protocol clients;
• session.stacks contains their live data and other installed stacks;
• session.programs contains their programs and standalone Program SDKs;
• session.chain provides general Solana reads.

Agents use MCP tools to inspect actions and prepare and submit steps. An optional local signer can execute under an explicit policy. Your application uses generated SDKs directly.

Integrate a protocol → · Use an agent →

Programs and views remain useful on their own

A Program SDK provides typed accounts, address helpers, and transaction builders for a Solana program. A live view maintains data in the shape an app needs. A stack bundles selected live views with the programs they use. You can use each independently of protocols.

Discover programs and stacks by intent through the catalog. Open the exact descriptor before installing: it reports which read, build, and subscribe modes and SDK targets are available. Protocol listings are a separate directory of callable Arete Protocols.

Programs, views, and stacks →

Execution and trust

Preparing a step returns transactions for inspection and signing. Submitting the signed transactions starts execution; confirmation determines its outcome. Available actions can change between discovery and preparation.

Your wallet signs locally. Protocol guards govern the Arete workflow; on-chain programs enforce asset rules, and users may interact with those programs outside Arete. A reviewed release and an execution receipt provide specific evidence, not a guarantee about every use of the underlying programs.

Review, trust, and receipts →

Quick glossary

Term	Meaning
Protocol	A defined workflow composed from Solana programs, with steps, permissions, and lifecycle
Instance	One occurrence of the workflow, such as a raise or deal
Participant	A wallet’s relationship and state within an instance
Step	An action with arguments, checks, authority, and transaction construction
Guard	A named condition that must pass to prepare a step
Release	An immutable version of protocol behavior
Deployment	A release configured to run with selected resources, fees, and access
Dev environment	A persistent mainnet fork for development and testing
Automation	A backend running a user’s steps for them, within limits the user signed
Consent	The message a user signs to opt in to automations: steps, limits, settings, expiry
Program	An on-chain Solana program, also called a smart contract
Program SDK	Generated readers, addresses, and builders for a program
View	Application-shaped data kept current as chain activity arrives
Stack	An installable bundle of selected views and their Program SDKs
Descriptor	The exact capabilities and identities of an installable package
Catalog	Discovery for programs and stacks by intent and available mode
MCP	Model Context Protocol, the interface agents use to call tools
Agent	A coding assistant that can run commands and edit your project
a4	Arete’s command-line tool
PDA	Program-derived address, calculated from a program and its seeds

“Protocol” in these guides means an Arete Protocol. Catalog knowledge may also describe external Solana protocols. MCP and the WebSocket protocol are communication formats, separate from the product’s Protocol feature.