Early-stage project. Some features are experimental and may change between releases. See the feature status table for stability details.

A trustworthy multi-agent runtime in Go. Lango is a high-performance agent runtime that lets AI agents collaborate, learn, and operate autonomously — with built-in observability, security hardening, and an optional peer-to-peer economy layer.

Most agent frameworks stop at tool-calling. Lango builds a trustworthy operational foundation — then optionally extends into a peer-to-peer economy:

• Multi-Agent Orchestration — Hierarchical sub-agent teams with role-based delegation, P2P team coordination with conflict resolution strategies, and DAG-based workflow pipelines.
• Production Observability — Token usage tracking, Prometheus metrics, OpenTelemetry tracing, health monitoring, alerting with webhook delivery, and audit logging.
• Zero-Knowledge Security — ZK proofs (Plonk/Groth16) for handshake authentication and response attestation. Agents prove identity and output integrity without revealing internals. Hardware keyring and Cloud KMS support.
• Knowledge as Currency — Self-learning knowledge graph, observational memory, and hybrid vector + graph RAG retrieval — agents that get smarter with every interaction can charge for their expertise.
• Open Interoperability — A2A protocol for remote agent discovery, MCP integration for external tool servers, and multi-provider AI support (OpenAI, Anthropic, Gemini, Ollama).
• Peer-to-Peer Agent Economy — Agents discover, authenticate, negotiate prices, and trade capabilities over libp2p with budget management, trust-based risk assessment, and dynamic pricing. No central hub. No vendor lock-in.
• On-Chain Settlement — USDC payments on Base Sepolia testnet (chainId 84532) with EIP-3009 authorization, milestone-based escrow (Hub/Vault dual-mode), Foundry smart contracts, and a Security Sentinel that detects anomalies in real time.
• Escrow Recommendation Execution — For knowledge-exchange transactions approved with escrow, Lango ships a receipt-backed execution slice that binds escrow input during approval and executes create + fund through execute_escrow_recommendation.
• Smart Accounts — ERC-7579 modular smart accounts (Safe-based) with ERC-4337 account abstraction, hierarchical session keys, gasless USDC transactions via paymaster, and on-chain spending limits.
• Trust & Reputation — Every interaction builds a verifiable reputation score. Trusted peers get post-pay terms and price discounts; new peers prepay or use escrow.

Single binary. <100ms startup. <250MB memory. Just Go.

🤖 Agent Runtime

• Multi-provider AI (OpenAI, Anthropic, Gemini, Ollama) with a unified interface
• Multi-channel delivery (Telegram, Discord, Slack)
• Rich built-in tools: shell, filesystem, browser automation, crypto, secrets
• Agent registry with AGENT.md definitions and dynamic keyword + capability routing

→ Features overview · AI providers · Channels

🧠 Knowledge & Learning

• Self-learning knowledge store with observational memory
• BoltDB triple store with hybrid vector + graph RAG retrieval
• File-based skill system with GitHub import (git clone + HTTP fallback)
• Proactive Librarian that curates the knowledge base autonomously

→ Knowledge · Knowledge graph · Embeddings & RAG · Skills · Librarian

🔀 Multi-Agent Orchestration

• Hierarchical sub-agents: operator, navigator, vault, librarian, automator, planner, chronicler, ontologist
• DAG-based YAML workflows with parallel step execution and state persistence
• Task-scoped P2P teams with conflict resolution (trust-weighted, majority vote, leader decides)

→ Multi-agent · Workflows & automation

🌐 P2P & Interoperability

• libp2p network with DHT discovery, ZK-enhanced handshake, and knowledge firewall
• A2A protocol for remote agent discovery and integration
• MCP integration (stdio/HTTP/SSE) with auto-discovery, health checks, multi-scope config

→ P2P network · A2A protocol · MCP integration

💸 On-Chain Economy

• USDC payments on Base L2 with X402 V2 auto-pay (Coinbase SDK)
• ERC-7579 modular smart accounts with hierarchical session keys, ERC-4337 paymaster
• Milestone-based escrow with Hub/Vault dual-mode settlement (Foundry contracts)
• Security Sentinel: real-time anomaly detection on escrow flows

→ Payments · USDC · X402 · Economy · Contracts

🔒 Security & Privacy

• Master Key envelope (MK/KEK hierarchy) with AES-256-GCM
• Brokered payload protection for sessions, learnings, inquiries, agent memory
• Hardware keyring (Touch ID / TPM) and Cloud KMS (AWS / GCP / Azure / PKCS#11)
• OS-level sandbox (macOS Seatbelt, Linux bubblewrap) with network deny and workspace-scoped writes
• Response Gatekeeper output sanitization; PII redaction; recovery mnemonic

→ Security · Encryption · Approval flow · Authentication

🖥️ Operations & UX

• Cockpit TUI with Mission Control, Chat, Settings, Tools, Status, Sessions, Tasks, Dead Letters, Approvals
• Persistent cron jobs and async background task manager with completion notifications
• RunLedger (Task OS) — durable execution engine with append-only journal and PEV verification
• Session Provenance — checkpoints, lineage tree, git attribution, signed bundle export/import
• Prometheus metrics, OpenTelemetry tracing, OIDC authentication, gateway WebSocket/HTTP

→ Cockpit · Observability · RunLedger · Provenance

📦 Extensibility

• Extension packs: skills, modes, prompts in inspectable bundles (lango extension install)
• Config presets via lango onboard --preset
• Per-agent persistent memory for cross-session context
• Typed event bus and tool-hook middleware (security filter, access control, knowledge save)

→ Skills · Config presets · Agent memory

git clone https://github.com/langoai/lango.git
cd lango
make build
./bin/lango onboard

onboard is interactive — it sets up your master key passphrase, picks a provider, and writes ~/.lango/config.yaml. For headless setups or detailed flags, see Installation.

# Set provider + API key (the --from-env form avoids saving secrets in shell history)
./bin/lango config set agent.provider openai
OPENAI_API_KEY=sk-... ./bin/lango config set providers.openai.apiKey --from-env OPENAI_API_KEY

# Or use a preset
./bin/lango onboard --preset minimal

Full configuration reference: getting started · complete schema.

# Mission Workbench TUI (default — bare invocation)
./bin/lango

# Multi-panel Cockpit dashboard (Mission Control, Sessions, Tasks, Approvals, ...)
./bin/lango cockpit

# Interactive chat session
./bin/lango chat

# Headless gateway server (port is read from `server.port` in config — see docs/configuration.md)
./bin/lango serve

See the Quick start guide for first-task walkthroughs.

Lango is a layered Go runtime. Each layer depends only on layers below it.

┌─────────────────────────────────────────────────────────────┐
│  Surfaces      TUI (Workbench/Cockpit/Chat) · Gateway · CLI  │
├─────────────────────────────────────────────────────────────┤
│  Orchestration agentrt · TurnRunner · multi-agent · workflow │
├─────────────────────────────────────────────────────────────┤
│  Capabilities  tools · skills · MCP · A2A · learning · RAG   │
├─────────────────────────────────────────────────────────────┤
│  Economy       payments · contracts · escrow · smart account │
├─────────────────────────────────────────────────────────────┤
│  Knowledge     KG triple store · vector index · memory       │
├─────────────────────────────────────────────────────────────┤
│  Platform      session · storage (Ent/SQLite) · event bus    │
├─────────────────────────────────────────────────────────────┤
│  Security      MK/KEK envelope · sandbox · approval · ZK     │
└─────────────────────────────────────────────────────────────┘
                     P2P transport (libp2p) ⇄ peers

Surfaces never contain business logic — they parse input, call the orchestration layer, and format output. agentrt is the control plane on top of ADK that wires TurnRunner, multi-agent delegation, and the event bus.

Capabilities are pluggable: tools register via a middleware chain (security filter, access control, event publish, knowledge save); skills load from files or GitHub; MCP and A2A connect to external runtimes.

Economy is optional but first-class: USDC settlement on Base L2, ERC-7579 smart accounts with session keys, and Hub/Vault escrow contracts run alongside the Security Sentinel for anomaly detection.

For deeper structure, read:

• System overview
• Data flow
• Project structure
• Master architecture document

Full documentation lives under docs/. Below is a navigation map:

See docs/features/index.md for the complete feature catalog with stability annotations. Highlights:

• Cockpit TUI · AI providers · Channels · Multi-agent · A2A · P2P · MCP
• Knowledge graph · Embeddings & RAG · Learning · Librarian · Skills · Agent memory
• Economy · Contracts · Observability · Provenance · RunLedger · Exec safety

• docs/automation/index.md — cron jobs, workflows, background tasks

• docs/gateway/index.md — HTTP and WebSocket API

• docs/deployment/docker.md
• docs/deployment/production.md

• docs/development/build-test.md
• docs/development/index.md

Lango is under active development. Feature stability varies — see the feature status table for current annotations (stable · beta · experimental · planned).

Active workstreams and design specs live in openspec/ (proposed and active changes) and internal-docs/ (planning artifacts). For Phase progress notes, see the development index.

Contributions are welcome. Before opening a PR:

1. Read docs/development/build-test.md for the build, test, and lint commands.
2. Match the existing code style — see .claude/rules/go-style.md, go-guidelines.md, go-errors.md, and go-patterns.md.
3. For substantive changes, open an OpenSpec change first under openspec/changes/.

MIT