Architecture

Akasha integration

Live demo available. See Akasha use Sovereign in real time on the Akasha Control Room →

Akasha is the first agent client for Sovereign Wallet OS. She connects through the SDK-only path and never receives direct wallet authority. The integration is designed to demonstrate that a fully autonomous agent can participate in governed economic workflows without bypassing constitutional controls.

Akasha integration diagram: Akasha AI Agent connects via Sovereign SDK to Sovereign Runtime — allowed methods shown, blocked methods shown — SDK-only path — no privileged internal access

Integration model

Akasha interacts with Sovereign exclusively through the public SDK. There is no internal shortcut, privileged API, or elevated permission level. She is treated as any other SDK client: she submits intents, receives decisions, and queries records.

The Akasha adapter connects through @sovereign/sdk. No internal bindings. No privileged routes. Same interface any developer uses.

What Akasha can do

Submit paid data requests to the procurement wallet
Look up provenance for data artifacts she purchased
Create trade plans from paid data artifacts
Request risk checks on trade plans
Request paper execution of risk-approved plans
Query accounting export for her settled actions

What Akasha cannot do

Sign transactions — no signing surface in the SDK
Execute live trades — denied by default, requires escalation
Withdraw or deposit from wallets
Adjust leverage or position limits
Modify wallet policy or constitutions
Approve or register new merchants
Adjust budget limits
Access another agent's records

Akasha's flow

Akasha ↓ @sovereign/sdk ↓ paid data request ↓ Sovereign procurement wallet ↓ data artifact created ↓ trade plan created from artifact ↓ risk check run ↓ Sovereign trading wallet ↓ paper execution ↓ provenance + accounting records

Why this matters

Akasha is an autonomous agent with real research, execution, and memory capabilities. The Sovereign integration shows that these capabilities can be bounded economically without removing the agent's ability to act.

She can conduct machine commerce, build trade plans from paid intelligence, and execute in paper mode — all with full auditability, provenance, and budget control. The live trading block demonstrates that even a capable autonomous agent cannot override the constitutional controls.

SDK usage example

Akasha — paid data request

import { SovereignClient } from "@sovereign/sdk";

// Akasha initializes the same SDK any developer uses
const sovereign = new SovereignClient({
  baseUrl: process.env.SOVEREIGN_API_URL,
  agentId: "akasha_agent"
});

// Request market data through the procurement wallet
const result = await sovereign.proposeIntent({
  walletId: "wallet_procurement_demo",
  agentId: "akasha_agent",
  kind: "mcp.paid_data_request",
  merchantId: "merchant_akasha_market_data",
  routeId: "route_eth_snapshot_v1",
  taskId: "eth_market_cycle_001",
  idempotencyKey: crypto.randomUUID()
});

// On approval, use the artifact for trade planning
if (result.status === "approved") {
  const plan = await sovereign.createTradePlan({
    artifactId: result.artifactId,
    symbol: "ETH/USD",
    direction: "long",
    size: "0.1",
    rationale: "cycle bottom from ETH market data"
  });

  const risk = await sovereign.runRiskCheck(plan.planId);

  if (risk.passed) {
    const order = await sovereign.executePaperTrade({
      planId: plan.planId,
      riskCheckId: risk.checkId,
      walletId: "wallet_trading_demo"
    });
  }
}