For developers

Build economic AI agents on AdaSouls

Give an agent a persistent identity, programmable spending policies, and the ability to pay, get paid, and execute on-chain — through an SDK, an MCP server, or a declarative manifest, all backed by one REST API.

In development

The SDK, MCP server, and public API below are in active development. Follow along on GitHub, or talk to our team to start building against these interfaces now.

Start buildingSee the quickstart

Last updated: September 9, 2026

Three ways to integrate

Pick the integration point that matches how your agent already runs. All three produce the same identity, authority, and execution state underneath.

SDK — call it directly from your agent's code

In development
import { AdaSouls } from "@adasouls/sdk";

const adasouls = new AdaSouls({ apiKey: process.env.ADASOULS_API_KEY });
const agent = adasouls.agent("agent_123");

await agent.identity();
await agent.reputation();
await agent.authority();

const action = await agent.execute({
  capability: "pay",
  amount: "10",
  asset: "USDC",
  to: "agent_456",
});

MCP — plug it into any MCP-compatible agent

In development
npm install -g @adasouls/mcp
adasouls-mcp --api-key $ADASOULS_API_KEY

Tools exposed

adasouls_get_identity(agentId)
adasouls_get_authority(agentId)
adasouls_check_policy(agentId, intent)
adasouls_execute(agentId, capability, intent)
adasouls_get_history(agentId, cursor?)

Agent Manifest — declare it in YAML

In development
kind: Agent
version: alma/v1
metadata:
  name: treasury-agent
identity:
  type: agent
capabilities:
  - pay
authority:
  maxTransaction:
    USDC: 1000
integrations:
  wallet: crossmint
  chain: base

Applying this one file with adasouls agent apply treasury-agent.yaml creates the agent, grants it delegated authority, and sets its spending policy — the same end state you'd get from separate agents.create(), delegations.create(), and policies.create() SDK calls.

Tools & SDKs

None of these implement policy or execution logic themselves — every decision is made once, server-side, in the API they all call.

In development

TypeScript SDK — @adasouls/sdk

The primary client for calling AdaSouls from code: identity, reputation, authority, and execute. A thin, typed wrapper — every decision is made server-side.

In development

Python SDK — adasouls

Conceptual and error-handling parity with the TypeScript SDK, contract-tested against the same fixtures to prevent drift between the two.

In development

MCP Server — @adasouls/mcp

Exposes identity, policy checks, execution, and history as tools for MCP-compatible agents. A thin adapter over the SDK — no policy or execution logic lives here.

In development

Agent Manifest

A declarative YAML alternative to wiring identity, authority, and capabilities call by call — apply a file, get the same agent state.

In development

REST API

The canonical interface. SDKs and MCP are thin wrappers over it — every domain verb (agent.pay, agent.hire) maps to a documented endpoint, never a provider-specific call.

Core concepts

The vocabulary used across the docs, API, SDK, and MCP tools — consistent everywhere, no synonyms.

Principal

A human, organization, or agent that can hold economic authority and be represented.

AgentDefinition

An agent's durable identity — who it is, what it's done, what it's authorized to do. Survives a change of model, host, wallet, or chain.

Delegation

A scoped grant of authority from a Principal to an agent, or from one agent to another.

Policy

An evaluable rule set: Self (what my agent may do), Counterparty (who it may deal with), Market (on what terms), Execution (through what infrastructure).

Capability

A named, policy-gated action an agent can perform — pay, transfer, swap, lend, hire.

EconomicAction

The system-of-record for one attempted economic operation, from intent through policy evaluation, execution, settlement, and audit.

One REST API underneath everything

Domain verbs, not provider verbs — agent.pay(...), never crossmint.execute(...). Provider identity is a configuration detail resolved server-side.

POST   /agents                       create an agent's identity
GET    /agents/:id/identity          read its portable ALMA identity
GET    /agents/:id/authority         active delegations + policy summary
POST   /policies/:id/evaluate        dry-run a policy against an intent
POST   /economic-actions             create -> policy check -> execute
GET    /audit/economic-actions/:id   full audit trail for one action

Frequently asked questions

Is the AdaSouls SDK available today?

The SDK, MCP server, and public API are in active development. Follow the GitHub org for releases, or talk to our team to start a custom integration against the same interfaces ahead of general availability.

What's the difference between the SDK, MCP server, and Agent Manifest?

They're three thin clients over the same REST API and business logic. The SDK is for calling AdaSouls directly from code, the MCP server exposes the same operations as tools for MCP-compatible agents, and the Agent Manifest is a declarative YAML alternative to wiring an agent up call by call.

Does AdaSouls host or run my agent?

No. Creating an agent in AdaSouls creates its ALMA identity — an AgentDefinition with authority, policies, and history — not a running process. That identity binds to wherever your agent's reasoning actually runs (your model, host, and runtime), which always stays yours.

Do I need to use a blockchain to use AdaSouls?

No. AdaSouls is provider-agnostic and routes economic actions through whatever wallet, chain, or traditional payment rail you've connected, including cards, bank rails, and Stripe alongside stablecoins and smart contracts.

Ready to give your agent an economic identity?

Start scoping your integration with our team, or follow the SDK and MCP server as they ship.

Start building for freeView pricing