Worldline

• 

• 

Inspiration

We kept coming back to a simple question: if autonomous machines can remember past situations, what should that memory actually change?

A drone remembering that a similar flight nearly failed is not useful if that memory lives in a separate system from the decision to move. It needs to affect the route selection, the safety check, and the final reservation of airspace.

WORLDLINE came from that idea. We wanted to make memory visible: not a chat history or a search result, but a prior near-miss that changes a machine’s future before it moves.

What it does

WORLDLINE is a shared episodic memory and commitment plane for autonomous machines.

Two agents attempt to reserve the same future airspace. Before committing, the planning agent retrieves a verified similar near-miss from CockroachDB using vector search. That memory selects a pre-validated vertical-separation maneuver.

The system then runs real serializable transactions. One original route commits; the conflicting route receives a retryable conflict and commits an alternate, safe corridor instead.

The control room shows:

• The recalled episode, similarity score, physical conditions, and selected maneuver.
• The unsafe counterfactual route alongside the committed safe worldline.
• The transaction retry and committed HLC timestamp.
• Changefeed confirmation before a route becomes authoritative.
• A durable receipt linking memory → decision → safety proof → world snapshot.

How we built it

The control room is a React/Vinext application deployed on Cloudflare Workers.

The agent runs in AWS Lambda. It uses Amazon Titan Text Embeddings v2 to embed the live scenario and Amazon Nova Micro to rank only pre-generated safe maneuver candidates. Model output never bypasses deterministic safety checks.

CockroachDB is the memory and commitment layer:

• maneuver_memories stores verified near-miss episodes with structured physical context and vector embeddings.
• A distributed vector index retrieves relevant, verified memories filtered by region and vehicle class.
• Serializable transactions reserve corridor capacity, write exclusion-cell claims, create route decisions, link memory reads, write an outbox command, and issue a receipt atomically.
• AS OF SYSTEM TIME reconstructs the world state at a recorded HLC timestamp.
• A sinkless changefeed is consumed by ECS Fargate and relayed to the control room as a live consistency witness.
• Versioned S3 receipts preserve durable decision evidence.

Challenges we ran into

The hardest part was making the conflict real and repeatable.

A staged animation is easy. Coordinating two actual distributed transactions so they both contend for the same capacity, produce a genuine retry, and still complete reliably required careful transaction ordering and retry handling.

We also had to keep non-database side effects outside retryable transactions. Bedrock calls and S3 receipt archival must never repeat because CockroachDB retried a transaction.

Multi-region latency was another practical lesson. A full live run includes embedding, constrained ranking, vector recall, serializable admission, CDC confirmation, and receipt archival. We moved the public control room to Lambda’s response endpoint so a successful long-running admission would not be cut off by API Gateway’s shorter integration timeout.

Accomplishments that we're proud of

• Memory is causal, not decorative: the recalled near-miss changes the selected maneuver.
• The collision avoidance is backed by real CockroachDB serializable transactions, not a frontend simulation.
• The system makes distributed-database behavior understandable in one visual moment: the route bends when the remembered maneuver commits.
• Changefeed confirmation is visible before a future is shown as authoritative.
• Every commitment has a durable, queryable provenance chain and historical world snapshot.
• We built a visual identity around the product itself: two worldlines meet, one commits, and one bends safely away.

What we learned

We learned that agent memory becomes much more valuable when it is attached to consequences.

Vector search alone can identify a useful past episode, but it cannot guarantee that two agents will not act on conflicting futures. Transactions alone can protect a reservation, but they cannot explain why a particular maneuver was selected.

Putting both in CockroachDB gave us one consistent chain of evidence: what was remembered, why it applied, what was rejected, what committed, and what the world looked like at that moment.

We also learned that production realism is mostly about boundaries: typed model outputs, deterministic validation, idempotency, bounded retries, CDC deduplication, and receipts that survive beyond MVCC retention.

What's next for WORLDLINE

Next, we want to move from the deterministic two-agent scenario to rolling planning horizons with more vehicles, live geofence updates, and region-specific policy constraints.

We would also add richer episodic memory lifecycle management: confidence decay, human verification workflows for newly learned memories, and evaluation tooling that measures whether recalled episodes improve safety and efficiency over time.

The long-term goal is a shared memory layer for autonomous systems that can answer a critical question before action: “Has this future almost gone wrong before—and what did we safely do about it?”

Built With

• agent-memory
• agentic-ai
• amazon-bedrock
• amazon-ecs
• amazon-nova
• amazon-titan
• amazon-web-services
• autonomous-systems
• aws-lambda
• change-data-capture
• changefeeds
• cloudflare-workers
• cockroachdb
• cockroachdb-agent-skills
• distributed-systems
• distributed-vector-indexing
• multi-region
• mvcc
• node.js
• react
• serializable-transactions
• typescript
• vector-database
• vector-search