Fiducia is a Raft-replicated control plane for distributed systems andAI-agent fleets. Hand off the hard parts of coordination —mutual-exclusion locks, semaphores,rate limiting, shared state,service discovery, elections, andcron — to an API that is consistent, fault-tolerant, and always exactly one source of truth.
$ curl -X POST https://api.fiducia.cloud/v1/locks/acquire \
-d '{"key":"orders/checkout","ttl":"30s"}'
→ {
"acquired": true,
"fencing_token": "00000000-1F4A",
"lease_expires": "2026-06-26T19:41:12Z",
"quorum": "3/5 committed"
}Stop running your own ZooKeeper or etcd cluster. Fiducia gives you the coordination primitives distributed systems fight over most — locks, limits, schedules, config, elections, and discovery — built on a single consistent core.
Fencing-token mutexes with automatic lease expiry — exactly one holder across your whole fleet — plus counting semaphores when you need up to N concurrent holders.
Distributed token-bucket and sliding-window limiters that share a single source of truth, so a quota is enforced consistently no matter which replica answers.
A replicated scheduler that survives leader failure. Schedule recurring or one-shot jobs and get at-least- or exactly-once delivery with durable history.
A linearizable, versioned key/value store for configuration and feature flags. Watch a key or prefix and get changes pushed the instant they commit — no polling, no drift.
Run your own elections on top of Fiducia. Campaign for a named leadership, hold it with a TTL lease, and step down cleanly — with a fencing token to defeat the stale leader you forgot about.
Register service instances with a heartbeat lease and look up only the ones that are actually alive. Crashed instances drop out on their own — no stale endpoints, no manual cleanup.
Autonomous agents run in parallel, retry, crash, and fork. The moment two of them touch the same task, budget, tool, or memory, they need the same correctness primitives as distributed databases.
Hand a job to a fleet and exactly one worker claims it. A fencing-token lock with a TTL lease keeps crashed, forked, or retried agents from double-booking work.
Put browser sessions, GPUs, paid APIs, inboxes, sandboxes, deploy lanes, and model providers behind one global limiter instead of per-replica counters that drift.
Run one planner, reviewer, compactor, or release coordinator at a time, backed by a consistent KV blackboard that pushes watched state changes as soon as they commit.
Fiducia coordinates agent processes. It does not plan tasks, choose models, store transcripts, judge semantic correctness, or prevent hallucinations.
Tasks, prompts, transcripts, artifacts, embeddings, and run history.
Shared authority, finite capacity, liveness, failover, and no-duplicate scheduling.
Reasoning, tool execution, output validation, and human escalation.
loop {
let claim = fiducia.claim(task_id, worker_id, lease_ttl).await?;
while work.is_running() {
fiducia.renew(task_id, claim.fencing_token).await?;
work.advance_one_safe_step().await?;
}
durable_store.commit_if_fence_is_current(
task_id,
claim.fencing_token,
work.result(),
).await?;
}Exactly-once external effects still require the target system to enforce a fencing token or stable idempotency key.
Every Fiducia operation is a committed entry in its shard’s replicated log. That is what turns “probably locked” into “provably locked” — and what lets the cluster scale out instead of up.
The keyspace is split into shards, and each shard is its own Raft group. Every lock, key, or schedule is an entry in its shard’s replicated log.
Each shard elects its own leader, so leadership — and write throughput — spreads across the whole cluster instead of funneling through one node.
An operation is acknowledged only once a majority of its shard has durably stored it — so a committed lock or job survives node loss.
A control plane watches every node, re-places shards off failed ones, and adds or drains capacity automatically — the cluster heals and grows on its own.
A Redis SETNX lock without fencing, a cron that double-fires after a deploy, a rate limiter that drifts between replicas — these are the bugs you find in production. Fiducia makes correctness the default. It is crash-fault tolerant (CFT), not Byzantine: it assumes your own nodes can crash, never that they lie.
A network partition can never elect two leaders. The minority side stops serving writes rather than diverge — so two clients never hold the same lock.
A lock acknowledged by Fiducia is durable on a majority of nodes. Lose a replica — or a whole availability zone’s minority — and committed state stays put.
Leader-elected scheduling means a cron job fires once, not once per replica, even across rolling deploys and failovers.
Point your services or agent fleet at one endpoint and get locks, limits, task claims, elections, KV watches, and schedules backed by a consensus you don’t have to operate.