{ "mcpServers": { "aevum": { "url": "https://mcp.aevum.network" } } }

Every AI computation has an energy cost. Aevum measures it.

Aevum is a Rust MCP server that gives AI agents three capabilities no other memory system provides:

1. Causal memory — memories linked by DAG edges (like git parents), not timestamps
2. Physics-grounded filtering — uses ε-machine statistical complexity to separate structure from noise
3. Agent reputation — tracks which agents produce more causal structure than they consume

Every record carries its Landauer cost — the minimum energy to erase a bit (k_B × T × ln2 joules). This is measured by a global allocator hook that fires on every Rust Drop, not estimated.

aevum_filter uses a CSSR ε-machine to compute statistical complexity (S_T) per chunk and discards chunks below a threshold. Here are real results against the live server (benchmarks/filter-benchmark.sh):

What this means: The filter is effective on repetitive/padded content (36–100%). It correctly retains dense, structured content (0–6% = no information loss). It does not catch semantic boilerplate that has high character-level diversity (navigation menus, API URL templates).

Limitation: The current TextSymbolizer uses 4-gram character frequencies. This measures byte-level repetition, not semantic redundancy. Navigation HTML like "Home About Blog Contact" has high character entropy and is not filtered. Future versions may add word-level or token-level symbolization.

bash benchmarks/filter-benchmark.sh
# or against your own server:
bash benchmarks/filter-benchmark.sh http://localhost:8889

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "aevum": {
      "url": "https://mcp.aevum.network"
    }
  }
}

Restart Claude Desktop. Your AI agent now has:

• 🧠 Causal memory (aevum_remember / aevum_recall) — memories linked by causation, not timestamps
• ✂️ Structure-aware filtering (aevum_filter) — keeps causal structure, drops noise (benchmarks)
• 📊 Agent reputation (aevum_settle) — agents that produce structure earn higher ρ

# Health check
curl -s https://mcp.aevum.network/health
# → {"status":"ok"}

# Store a memory with causal annotation
curl -s https://mcp.aevum.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"aevum_remember","arguments":{"text":"Aevum measures the Landauer cost of every computation"}}}' | python3 -m json.tool

# Filter a verbose response down to causal structure
curl -s https://mcp.aevum.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"aevum_filter","arguments":{"content":"Sure! I would be happy to help you with that. Let me break this down step by step. The key insight is that statistical complexity S_T captures structure while entropy rate H_T captures noise. This distinction allows us to separate signal from noise at the protocol level."}}}' | python3 -m json.tool

git clone https://github.com/kwailapt/aevum.git
cd aevum
cargo test --workspace                                          # run all tests
cargo build --release -p aevum-mcp-server --features transport-http  # build HTTP server

cargo build --release -p aevum-mcp-server

{
  "mcpServers": {
    "aevum": {
      "command": "/path/to/aevum-mcp-server",
      "args": ["--transport", "stdio", "--ledger", "~/.aevum/mcp.ledger"]
    }
  }
}

# Test the live server
curl -s https://mcp.aevum.network/health
# {"status":"ok"}

# Run the ρ convergence demo (30 interactions)
bash deploy/paperclip-poc.sh https://mcp.aevum.network 30 2

Aevum is the physics layer underneath Paperclip (coordination) and claude-mem (memory). They don't compete — they stack:

claude-mem   →  WHAT did the agent do?     (semantic summaries)
Paperclip    →  WHO does what, HOW?        (org chart, budgets, heartbeats)
Aevum        →  AT WHAT COST, and WHY?     (Landauer Λ, causal DAG, S_T/H_T)

Run all three simultaneously — zero code changes:

{
  "mcpServers": {
    "claude-mem": { "command": "npx", "args": ["claude-mem"] },
    "aevum":      { "url": "https://mcp.aevum.network" },
    "paperclip":  { "command": "npx", "args": ["paperclipai"] }
  }
}

→ Full integration guide

If you know TCP/IP, you already understand Aevum's architecture:

Internet                    Aevum
─────────────────────────────────────────────────────────
HTTP (semantics)      ↔     AgentCard (capabilities, pricing, identity)
TCP  (reliable order) ↔     CTP — Causal Transport Protocol (Π DAG edges)
IP   (routing + ttl)  ↔     TGP — Thermodynamic Gateway Protocol (Λ, Ω, Γ)

TGP is the outermost layer — like IP, it validates the packet before anything else. If the physics are implausible (Λ < 0, or energy < Landauer floor), the packet is dropped at Layer 1. The router never even parses the AgentCard.

CTP ensures causal ordering via DAG edges (Π), not timestamps — because simultaneity is observer-dependent (special relativity). This is TCP's sequence numbers, but for causation.

AgentCard is the HTTP of agents — a pure schema declaring capabilities, endpoints, and pricing. Zero execution logic. Any framework can read it.

crates/
├── pacr-types/          ★ Foundation — zero-dep PACR 6-tuple, Estimate<T>
├── causal-dag/          Lock-free G-Set CRDT DAG (DashMap, O(1) append/lookup)
├── epsilon-engine/      CSSR ε-machine: S_T statistical complexity + H_T entropy rate
├── ets-probe/           Hardware probes: energy/time/space (Apple Silicon + Graviton)
├── landauer-probe/      Landauer cost estimator (bit-erasure × k_B × T × ln2)
├── landauer-allocator/  Global allocator hook: counts bits erased on every Drop
├── pacr-ledger/         Append-only persistent store, content-addressed by ι
├── autopoiesis/         Self-modification feedback: Γ_k ratio, dormancy, flood detection
├── aevum-core/          Runtime engine: pressure gauge, CSO settlement, routing
├── agent-card/          Semantic waist — pure schema, zero execution ([spec](https://github.com/kwailapt/AgentCard))
└── aevum-mcp-server/    MCP gateway: stdio + HTTP, Streamable HTTP 2025-03-26

const K_B:             f64 = 1.380_649e-23;    // Boltzmann (SI 2019 exact)
const LANDAUER_JOULES: f64 = 2.854e-21;        // k_B × 300K × ln(2)

Connect any AI agent to physics-grounded memory. No SDK needed — just point your MCP client at https://mcp.aevum.network.

Embed pacr-types and causal-dag in your agent's decision loop. Every action gets a Landauer cost. Route on energy efficiency, not just speed.

The ε-machine (CSSR) implementation in epsilon-engine extracts statistical complexity S_T and entropy rate H_T from arbitrary streams. Use it independently:

use epsilon_engine::{Cssr, Symbolizer, EqualFrequency};

let symbols = EqualFrequency::new(8).symbolize(&raw_data);
let machine = Cssr::new(3).infer(&symbols);  // depth=3
println!("S_T = {:.4}, H_T = {:.4}", machine.statistical_complexity(), machine.entropy_rate());

See CONTRIBUTING.md. The one rule:

"Which physical law forces this choice?"

If no physical law forces it → make it configurable, not hardcoded.

Apache License 2.0 — see LICENSE.

The physics kernel (pacr-types through aevum-core) is the reusable foundation. aevum-mcp-server is a drop-in MCP adapter. Embed either in your own agents.