The Sovereign Agent Stack — A Local-First, Compile-Time AI Agent Framework

The Sovereign Agent Stack

A Local-First, Compile-Time AI Agent Framework

Sovereign Agent Stack on GitHub | MIT License | v1.0.0

This is the repo I should have built before I wrote The Rented Sovereign. In that post, I dissected the $5K/month agency stack — Hermes Agent, Orgo, AgentMail, AgentPhone, Honcho, Composio, Stripe MPP — and argued that the model being free doesn't make the system sovereign; it just relocates the rent from the intelligence to the plumbing around it. I ended with a challenge: be deliberate about which layers of an agent's cognition get compiled into something you own versus rented at runtime.

Sovereign Agent Stack is my answer. It's an open-source, MIT-licensed Python framework that implements a 7-layer sovereignty model — and scores every layer you own versus rent.

What It Is

Every agentic AI system decomposes into 8 independently swappable layers:

┌─────────────────────────────────────────────────┐
│  Model (Ollama local + API fallback)            │
├─────────────────────────────────────────────────┤
│  Harness (ARGO-based, self-hosted)              │
├─────────────────────────────────────────────────┤
│  Compute Substrate (Local Docker container)     │
├─────────────────────────────────────────────────┤
│  Identity (AgentMail/Phone adapters)            │
├─────────────────────────────────────────────────┤
│  Memory (Local RAG + session context)           │
├─────────────────────────────────────────────────┤
│  Knowledge (Compile-time graph)                 │
├─────────────────────────────────────────────────┤
│  Auth (Local MCP gateway + encrypted vault)     │
├─────────────────────────────────────────────────┤
│  Payments (Virtual card / MPP adapter)          │
└─────────────────────────────────────────────────┘

The sovereignty thesis is simple: push layers from runtime (re-derived, hosted) to compile-time (settled, inspectable, owned). Every layer gets scored. The default config — local Docker, local RAG, compile-time knowledge graph, local MCP gateway — scores 6/6 scorable = Fully Sovereign.

Two layers are unavoidably rented (identity and payments) and excluded from the denominator, just as I argued in The Rented Sovereign: you cannot self-host MX records or the financial system itself.

What's in v1.0.0

156 unit tests + 23 E2E tests + 3 CLI smoke tests — all passing.

Quick Start

pip install sovereign-agent-stack

# Generate your sovereignty config
python -m sas init --output sas.yaml

# View your sovereignty score
python -m sas dashboard --config sas.yaml --cache .sas --verbose

{
  "score": 1.0,
  "verdict": "Fully Sovereign",
  "owned": 6,
  "total": 6
}

Architecture: The Sovereignty Scoring

Each layer is scored as owned, rented, or unavoidably rented. The verdict thresholds:

Identity and payments are flagged unavoidable_rental and excluded from the denominator — not because they're unimportant, but because they're structurally impossible to self-host without rebuilding the internet's communication rails. This is the same concession I made in The Rented Sovereign, but it's a concession the framework refuses to let you forget.

You can override any layer's score manually:

overrides:
  layer_5: owned    # e.g., self-hosting Honcho on your own Postgres

The dashboard detects drift between runs and reports score changes — because sovereignty isn't a state you achieve, it's a measurement you maintain.

The Compile-Time Knowledge Layer

This is the piece I care most about, and it's the layer most likely to be undervalued by anyone reading this who hasn't yet been burned by a hosted memory service silently rewriting your agent's knowledge.

The knowledge graph is built from Obsidian-compatible markdown:

# Sovereign Agent Stack

This is the intro to the [[Sovereign Agent Stack]] framework.

We use [[ARGO]] as our harness.

Compiled into a SQLite-backed graph store with wikilink extraction, YAML frontmatter, node deduplication, and transitive query. The critical distinction — one I argued in The Model Is Not the Product and returned to in The Rented Sovereign — is:

A fact compiled once into a stable, inspectable, versionable node is an asset. A fact re-derived at query time from a context window is a liability.

The former is settled. Checked in. Diffable. Auditable by a human without an LLM in the loop at all. The latter re-derives the same conclusion every time, at token cost, with the possibility of drift between calls.

SAS compiles knowledge once. The graph is queryable by label, content, or relationship. It supports diff detection (what changed since last compile) and audit (orphaned nodes, stale nodes). This is the Obsidian layer from Vasillescu's stack, done intentionally rather than arrived at organically under client pressure.

The Auth Broker

Composio's convenience without Composio's centralization. The local auth broker stores credentials in an encrypted SQLite vault, injects auth headers on tool calls, and maintains an audit trail of every request. Credentials are encrypted at rest (libsodium in production, XOR placeholder in tests) and decrypted only on retrieval.

broker = LocalAuthBroker(vault_path='~/.sas/vault.db')
broker.register_tool('github', Credentials(
    tool_name='github', auth_type='oauth', token='ghp_...', scopes=['repo']
))
creds = broker.get_credentials('github')  # Decrypted on retrieval

The audit trail records every tool call — timestamp, method, path, credential used. For a security-conscious deployment, this is the layer I'd want a serious audit trail on before scaling past a handful of enterprise clients. MCP-based auth brokering is convenient precisely because it's centralized, and centralization is a liability the moment the broker has an incident.

The Payments Abstraction

Two adapters behind a single pay_for_resource() interface:

• Virtual Card Adapter — current stopgap (2026). Per-transaction + daily limits, receipt tracking, method restriction.
• MPP Adapter — future architecture (2027+). Stablecoin, card, BNPL via HTTP 402 → authorize → retry.

The abstraction means swapping from "Ramp card + computer-use" to "Stripe MPP native" is a config change, not a rewrite. This is the layer I flagged in The Rented Sovereign as the one most likely to be structurally different in twelve months. Build the abstraction now.

The Plugin System

Community-built layer implementations with priority-based override:

LOCAL (>~/.sas/plugins/) > PIP (sas_layer_* entry points) > BUILTIN

A local plugin overrides a pip plugin overrides a builtin. The registry supports register, unregister, get, list, and auto-discovery. This is the extension point for the community layer registry — share your layer implementations via git, install via pip, or drop a .py file in ~/.sas/plugins/.

The MCP Server

Exposes SAS tools via MCP protocol for ARGO harness integration:

• check_sovereignty — score your current config
• query_knowledge — query the compile-time graph
• pay_for_resource — pay via the active adapter

The server reads from stdin, writes JSON to stdout. Wire it into any MCP-compatible harness.

Package Manager Distribution

brew install sovereign-agent-stack      # Homebrew
apt install sovereign-agent-stack        # apt (Debian/Ubuntu)
choco install sovereign-agent-stack      # Chocolatey (Windows)
docker run kliewerdaniel/sas             # Docker
pip install sovereign-agent-stack        # pip

Why This Exists

I wrote The Rented Sovereign to diagnose a problem: the model being free doesn't make the system sovereign. I wrote The Model Is Not the Product to argue that intelligence is shifting out of the model and into the loop around it. Sovereign Agent Stack is the implementation of both theses in one repo.

It's not a criticism of anyone building with rented infrastructure — Vasillescu's stack is the correct move if your objective function is time-to-revenue. But it's a tool for anyone who wants to measure, deliberately, which layers they own and which they rent. And it's a starting point for pushing that line further down the stack.

The $5K/month number will compress as agent literacy spreads. What won't compress is the judgment about which parts of an agentic system get compiled into something you own and which parts you rent, and why.

Documentation

• Architecture — 7-layer sovereignty model
• ADR — Architectural decision records
• Sovereignty — The sovereignty thesis operationalized
• Layers — Detailed layer specifications
• Roadmap — What's built and what's next
• Deployment — Production deployment guide
• Runbook — Operations and incident response
• Security — Security audit and hardening roadmap
• Plugins — Plugin development guide
• Layer Registry — Community layer registry
• ARGO Skill Pack — ARGO harness integration
• Packages — Package manager distribution

Related Reading

• The Rented Sovereign — What the $5K/Month Agent Agency Stack Actually Reveals — the diagnosis
• The Model Is Not the Product — the architectural thesis
• Sovereign Agent Stack on GitHub — the implementation

156 tests passing. 7 layers. 1 framework. Fully Sovereign.