Memora

The Cloudflare Zero Trust of agent state.

Your security stack watches the network. Nothing watches what your agents tell each other.

Memora is the missing layer — Byzantine-fault-tolerant shared memory where one compromised agent is mathematically unable to fork the state of the rest, and every write is signed, attributable, and exactly replayable.

pip install memora-swarm

You aren't paying for message delivery. You're paying for mathematical certainty that a single compromised agent can't fork the swarm.

Why

When you run many agents against one shared memory, that memory is your weakest link. A single agent that gets prompt-injected, goes rogue, or simply malfunctions can write poison that every other agent then reads and trusts. Plain key-value stores (Redis, etc.) have no defense — last write wins, no matter who wrote it.

Memora replaces that shared store with an engine that is correct under adversarial writers:

• CRDTs — concurrent writes merge deterministically; the swarm never forks, no locks.
• Trust-weighted aggregation — numeric contributions are combined by a robust mean that down-weights outliers instead of averaging them in.
• Byzantine conviction (ACFA) — an agent that says different things to different peers (equivocation) is detected and evicted. Up to f malicious agents in a group of ≥ 2f+3 cannot move the agreed result. Based on the ACFA paper: arXiv:2607.10305.

Every write is signed by a self-certifying node identity and appended to a replayable log — so any state is attributable and auditable after the fact.

Quickstart

import memora_swarm as memora

# One key is the whole engine. Get a free key at https://memora.optitransfer.ch
db = memora.Blackboard(
    "./swarm.memora",
    node_id="agent_12",
    api_key="opti_sk_...",
)
db.connect("research-swarm")   # join a room; every agent in it shares one memory

# Shared key/value state — CRDT-merged. get() returns the set of current values.
db.put("best_hypothesis", "H3")
print(db.get("best_hypothesis"))            # -> ['H3']

# Byzantine-tolerant numeric aggregation: submit, then resolve the agreed result.
#   resolve(round, f) -> (aggregate_vector, acfa_root, convicted_node_ids)
db.submit_tensor("reward_estimate", [0.71, 0.68, 0.73], round=1)
vector, acfa_root, convicted = db.resolve(round=1, f=1)
print(vector, "convicted:", convicted)      # poisoners are evicted, not averaged in

That's it — no server to run. Your key connects you to the hosted relay, which does the CRDT merge, trust-weighting and Byzantine aggregation for you.

Use it with your stack

Memora is a plain shared-memory backend, so it drops under the agent frameworks you already use (LangChain, CrewAI, AutoGen). See the docs for copy-paste adapters: https://memora.optitransfer.ch/docs

Pricing

25,000 semantic ops free on signup — unlimited agents, the full engine, no feature gates. An "op" is a semantic state transition (a put or a submit_tensor); keepalive, sync and reads are never billed. At 85% of the free allowance you're prompted to add a card so nothing stops mid-run; after that it's metered at $0.35 / 1,000 ops ($0.20 / 1,000 above 2M/mo). The same key upgrades in place — your swarm never re-keys.

Links

• Home & docs — https://memora.optitransfer.ch
• Get a key (dashboard) — https://memora.optitransfer.ch/dashboard
• Live swarm monitor — https://memora.optitransfer.ch/monitor

Made under the optitransfer.ch umbrella.