Built on the ACFA paper — coordinator-free Byzantine aggregation

The Byzantine Firewall
for AI agent swarms

A drop-in replacement for Redis in multi-agent systems — where a single prompt-injected agent cannot poison the shared memory of the other 49. You aren't paying for message delivery. You are paying for mathematical certainty.

Sync in 3 secondsWatch an agent get convicted →

Exact Q16.16 integer math · an agent on ARM and one on x86 resolve to the identical byte sequence

The silent fork

Frameworks run dozens of agents over shared state in a dumb key-value store.

AutoGen, CrewAI, LangGraph — they all point at Redis or Postgres. If one agent is prompt-injected and writes poisoned JSON or tensors, every other agent reads the poison and the swarm hallucinates. On a network partition, Redis forks silently and never tells you. There is no mathematical guardrail for shared agent state.

Memora is that guardrail.

# Redis, network partition
agent_A> SET policy {"risk": 0.2}
agent_B> SET policy {"risk": 0.9}   # partitioned
# ...heals...
> GET policy
"{\"risk\": 0.9}"   // silently forked. which won?

# Memora, same partition
> db.get("policy")
root 0bf8038db4421365   // both replicas re-converge, byte-identical

Near-zero friction

Three lines. Under three seconds to first sync.

1

Install

One pre-compiled Rust wheel. No C-extensions, no NumPy, no build step.

pip install memora
2

Paste your key

One key, the whole engine — CRDT, E4 trust and ACFA conviction. Free for 50k ops/mo, then metered.

db = memora.Blackboard("./swarm.memora",
  node_id="agent_12", api_key="opti_sk_...")
3

Synced

Background delta-sync via the nearest region. "Synced" prints in under 3 seconds.

db.connect("swarm_001")
# → Synced ✓

Three layers, gated by tier

The same math ships to our cloud and on-prem to you — unchanged.

L1
OR-Set CRDT + delta-state
Conflict-free JSON beliefs. Never forks.
Included
L2
E4 trust-weighted mean
Smoothly down-weight conflicting state by trust.
Included
L3
ACFA Q16.16 multi-Krum + G-Set
Byzantine-robust tensors; auto-ban equivocators.
Included

Shield · live conviction

When an agent equivocates, the math bans it. Permanently.

round 1  · 5 agents submit signed tensors
         · resolved root  0bf8038db4421365   byte-identical across the swarm
         · agent_5 signs TWO conflicting round-1 tensors  ⚠ equivocation
         · self-authenticating G-Set conviction proof forms automatically
         · convicted set = [agent_5]   → excluded from aggregation
         · clean resolved root  0bf8038db4421365   (honest state intact)
round 2  · agent_5 attempts to rejoin  →  BANNED (permanent)

No coordinator. No human in the loop. The conviction proof is a mathematical object anyone can verify — powered by the same Q16.16 kernel in the ACFA paper.

One full service. Metered by the op.

Every agent gets the whole engine — CRDT, E4 trust, and ACFA Byzantine conviction. You only pay for the ops you run.

Start here — no card
Free
$0
  • ·The full service: CRDT + E4 + ACFA
  • ·Unlimited agents
  • ·50,000 ops / month
  • ·Then add a card to keep going
pip install memora
Free → metered, same key
The whole service, one price
Metered
$0.35/ 1,000 ops
  • ·Everything, unlimited agents
  • ·First 50,000 ops / month free
  • ·$0.35 / 1,000 ops
  • ·Drops to $0.20 / 1,000 above 2M / mo
Add a card
On-prem
Enterprise
Custom
  • ·On-prem relay binary (the moat)
  • ·SSO + dedicated support
  • ·Custom SLAs + volume pricing
  • ·The same math, inside your perimeter
Contact

An op is a semantic state change — a put or a tensor submission, never keepalive or sync chatter. Idle swarms cost nothing. At 85% of the free allowance we prompt you to add a card so nothing ever stops mid-run.