Two agents, one task, no silent duplicate work.

The failure is duplicate work, not forgetting

Shared recall makes every agent better informed. It does not stop two of them from starting the same task. A researcher and a writer can read the same memory, reach the same conclusion, and each decide independently that they are the one who should act on it.

Titen's requirements name that outcome directly: duplicated work, conflicting actions, accidental data sharing, and confident reuse of untrusted memory. The canonical scenario has four roles — a researcher recording source-backed findings and unresolved uncertainty, a writer compiling a bounded cited context pack, an operator claiming the delivery task and recording execution evidence, and a reviewer tracing claims back to evidence.

That scenario succeeds when the writer and operator reuse the research without repeating it, when no two agents silently own the same task, and when a handoff can be resumed from explicit state. Retrieval quality alone cannot deliver any of the three.

Five primitives, no scheduler

Titen ships only the state needed to prevent silent collisions. Each one is an ordinary authenticated route with its own scope, not a convention you assemble out of a key-value store and hope every agent follows.

• Checkpoint — resumable progress, upserted on organization, subject, agent and kind.
• Lease — expiring ownership of one bounded work item, 10 seconds to 24 hours.
• Handoff — an explicit transfer naming the recipient, optionally carrying a context pack and a checkpoint.
• Outcome — completion or failure, linked to evidence.
• Idempotency key — retry-safe mutation identity.

Claim the work before you do it

An agent acquires a lease on the resource it is about to touch. A live lease held by another principal returns 409 with the expiry and nothing else: no holder, no purpose, so probing for leases leaks nothing beyond the fact that this one is taken.

curl -X POST http://127.0.0.1:8787/v1/leases \
  -H "authorization: Bearer $TITEN_API_KEY" -H 'content-type: application/json' \
  -d '{"resource_type":"deploy","resource_id":"checkout-service",
       "purpose":"run rollback smoke","ttl_seconds":600}'

# The second agent to ask gets a 409 and the expiry, and starts nothing:
# {"error":{"code":"CONFLICT",
#   "message":"Resource is leased by another principal until 2026-07-30T10:58:13.829Z."}}

• There is no renew route. Acquiring again returns a new lease id, so keep the id from the most recent acquire.
• Release with DELETE /v1/leases/:id; an owner or admin can force-release an organization-scoped lease.
• POST /v1/handoffs then names who continues, and only the target principal may resolve it.

Four of the nine MCP tools are coordination

A compatible agent host gets this over one authenticated endpoint, with no Titen client library and no SDK in the agent process.

• titen_lease_acquire takes a coordination lease on a resource.
• titen_checkpoint_save writes or updates task state.
• titen_checkpoint_get reads the current checkpoint for a subject and kind.
• titen_handoff creates a handoff to another principal.
• The remaining five cover the memory loop: project resolve, remember, consolidate, compile, feedback.

Where this stops

Titen records that a coordination decision was made. It does not make one. Running an agent or model loop, and general workflow orchestration, are explicit non-goals — your orchestrator still chooses what runs next.

Leases are cooperative. They are advisory state your agents agree to check, not a fence on database writes, so this prevents silent collisions between participating agents rather than stopping a process that never asks.

• Nothing sweeps expired leases in the background. A crashed holder blocks the resource until its TTL runs out, so keep TTLs short.
• One Titen process is one core. Measured FTS-only on an 8-core host, compile throughput fell from about 1,700/s at 1,000 claims to about 90/s at 100,000, which is why the documented beachhead is 2–10 agents on one project rather than a fleet.
• Coordination is verified locally: the shared Bun/SQLite and local workerd/D1 contract suite. There is no live multi-agent production deployment to point at.