SwarmOSrc1

Treasury infrastructure for autonomous agents

Normal wallets assume one human. SwarmOS safely manages many agents with scoped spend, approvals, and receipts.

Programmable vaults, policy-gated execution, and hash-chained receipts. Give your AI agents spend controls that actually work.

Request Early AccessTry the Demo

How It Works

Step 1

Register & Authenticate

Generate Ed25519 keypair, register agent, issue time-bounded session key. Server never holds private material.

Step 2

Define Policy & Create Vault

Set per-action limits, chain allowlists, and approval thresholds. Create a capital cell (vault) bound to your policy.

Step 3

Execute & Verify

Submit intent → policy check → risk score → sign → execute → hash-chained receipt. Circuit breaker protects on anomaly.

The Problem SwarmOS Solves

Teams running multiple AI agents face a simple question: who controls the money?

Without SwarmOS

  • ✗Shared wallet keys — one compromised agent drains everything
  • ✗No spend limits — a hallucinating LLM can burn your entire budget
  • ✗No audit trail — you find out about unauthorized transfers after the fact
  • ✗No kill switch — when something goes wrong, you scramble to revoke access manually

With SwarmOS

  • ✓Isolated vaults per agent — blast radius is one cell, not your treasury
  • ✓Policy-gated execution — per-action limits, approval thresholds, chain allowlists
  • ✓Hash-chained receipts — every action is signed, sequenced, and independently verifiable
  • ✓4-state emergency machine — NORMAL → DEGRADED → SAFE_READONLY → HARD_STOP in one call

Architecture

5 bounded domains, 25+ API endpoints, 11-step signing pipeline, 4-state emergency machine

Identity Control

  • Ed25519 Admission
  • Session Keys
  • Capability Tokens

Treasury Runtime

  • Wallet Kernel
  • Capital Cells
  • Signing Pipeline

Policy & Risk

  • Policy Engine
  • Budget Tracking
  • Emergency Controls

Verification

  • Preflight Checks
  • Post-Verifier
  • Background Audit

Security Observability

  • 10-Rule Scanner
  • Event Pipeline
  • Receipt Chain

Built for Trust

342

Tests

Including 30 adversarial tests across 8 attack surfaces

8

Security Invariants

Non-negotiable properties with dedicated verification suite

4

Operational Drills

Mandatory SAFE_READONLY, stale session, recovery, verifier drills

rc1

Release Candidate

Feature-complete, pilot-ready, documented known limitations

Developer-First SDK

Register an agent, create a vault, and execute a policy-gated transfer in 15 lines of Python. Every action produces a hash-chained receipt.

  • Ed25519 key generation built-in
  • Session keys with automatic signing
  • Approval artifacts for high-risk actions
  • Emergency controls (engage/release)
quickstart.py
from swarmos_sdk.client import SwarmOSClient

client = SwarmOSClient()

# Register agent
client.generate_keys()
client.register()
client.issue_session_key()

# Create vault with policy
client.create_policy("my-policy",
    per_action_limit="500",
    chain_allowlist=["local"])

cell = client.create_cell("local", "ETH",
    "my-policy", "operations vault")
client.deposit(cell["cell_id"], "1000")

# Execute transfer (policy-gated, signed, receipted)
result = client.execute(
    cell["cell_id"],
    "transfer.external",
    "local", "ETH", "50",
    "0xrecipient"
)
print(f"Receipt: {result['receipt_id']}")

Get Early Access

SwarmOS is in release candidate. We're onboarding pilot operators for 3-5 person teams running 5-20 autonomous agents.