Synapse: Transactional Memory Engine for AI Agents

The ACID-compliant brain for autonomous AI. Fixes agent amnesia and concurrent writes via Aurora & DynamoDB

Comment

Inspiration

AI agents are trapped in a stateless loop. Developers are duct-taping vector databases to LLMs and calling it "memory." It's not memory; it's semantic search. When autonomous agents need to share state, hand off tasks concurrently, or maintain strict ACID compliance across distributed operations, vector databases fail catastrophically. We built Synapse to fix this fundamental architectural flaw in AI infrastructure.

What it does

Synapse is a transactional memory and state engine for autonomous AI agents. It provides a REST API for agents to write relational state, log immutable events, and visualize their knowledge graph in real-time. It is the infrastructure layer that turns a stateless chatbot into a stateful, production-ready autonomous system.

What Problem Synapse Solves AI agents are smart but amnesiac. Every major LLM framework — LangChain, CrewAI, AutoGen — makes it trivial to build an agent that reasons well. None of them solve what happens to that agent's state between sessions, across multiple concurrent instances, or when something goes wrong at 2am and you need to know exactly what it did and why.

Developers building production agent systems run into the same three walls every time:

1. Agents forget everything. Context windows expire. Sessions end. The next request starts from zero. A customer support agent that learned a user prefers refund-over-replacement will forget that preference the moment the session closes. Every interaction becomes a first interaction.

2. Concurrent agents corrupt shared state. When two agents — say, a billing bot and a support bot — write to the same customer record within the same 200ms window, traditional vector stores and key-value caches offer no transactional guarantees. No locks, no isolation, no rollback. State corruption is not a theoretical risk at scale — it is a guarantee.

3. There is no audit trail. When an agent makes a bad decision — approves a fraudulent claim, sends the wrong message, updates the wrong record — there is nothing to replay. No timestamped log of what it wrote, when, and why. Debugging a multi-agent system without an immutable event log is forensic archaeology in the dark.

Synapse is a purpose-built memory API that solves all three. It gives autonomous agents a transactional, ACID-compliant memory layer backed by Aurora DSQL for relational state and DynamoDB for immutable event logging — accessible over a single REST API.

How we built it

We did not use AWS databases as a dumb JSON dumping ground. The architecture is deliberately split to prove engineering intent:

Amazon Aurora DSQL: We chose DSQL over standard Postgres because AI agents operate asynchronously and concurrently. DSQL's distributed, active-active architecture handles simultaneous state updates without locking. We built a highly normalized schema (Agents, Memories, Relationships) using raw AWS SDK v3—zero ORMs.

Amazon DynamoDB: We implemented a strict Single-Table Design for the Event Log. Every agent action fires an immutable event here for infinite write throughput and complete auditability.

Vercel & v0: We used v0 to scaffold the Next.js App Router interface, but ruthlessly customized the UI, typography, and micro-interactions to avoid the generic "hackathon template" look. We built a live React Flow knowledge graph, a polling engine for the event stream, and a concurrent stress-tester directly into the dashboard.

Core

Layer Technology Version Role
Framework Next.js App Router 14.2.35 Server Components, API routes, streaming
Language TypeScript 5.4+ End-to-end type safety
Runtime Node.js 20.x Vercel serverless runtime
Styling Tailwind CSS 3.4+ Utility-first, dark-mode native

Databases

Database Version Purpose
Aurora DSQL AWS SDK v3.1073 ACID-compliant relational state
DynamoDB AWS SDK v3.1073 Immutable event log

Who It's For

Synapse is built for the engineers and teams who have already shipped an AI agent and discovered that "it works in a demo" is not the same as "it works in production."

Who The specific pain What Synapse gives them
AI backend engineers Agents built on LangChain / CrewAI lose context between sessions; custom Redis/Postgres memory layers take weeks to build correctly A drop-in REST API — write a memory node with one POST, retrieve the full graph with one GET, no framework coupling
Startups shipping agent products Racing to production with no time to design a memory architecture; concurrent agents hitting the same user records Managed infrastructure with SERIALIZABLE isolation already built in — no distributed systems PhD required
Enterprise AI teams Regulatory and compliance requirements demand a full audit trail of every AI decision An immutable DynamoDB event log — every agent action timestamped, persisted forever, replayable on demand
CTOs evaluating agent infrastructure Evaluating whether multi-agent systems can meet enterprise SLAs A live ACID stress test they can run themselves: 50 concurrent writes, observable pass/fail, real database

Challenges we ran into

The hardest challenge wasn't connecting the databases; it was proving DSQL's value proposition visually. It is easy to claim "zero race conditions," but hard to show it. We had to engineer an in-app stress tester that fires 100 simultaneous Promise.all() writes to DSQL and renders the exact timing, success, and failure metrics to the user in real-time. Additionally, keeping the React Flow memory graph performant while injecting new nodes via 3-second polling required strict memoization and edge-diffing logic to prevent UI thrashing.

Accomplishments that we're proud of

The Stress Test: 100 concurrent distributed writes. 100% success rate. Zero race conditions. Proven in the UI. -The Dual-Database Sync: Flawless data flow between DSQL (relational state) and DynamoDB (event log) via Next.js API routes. -The Live Graph: Rendering 200+ interconnected, color-coded memory nodes with animated relationship edges that update in real-time as agents write state.

What we learned

Vector databases are the wrong tool for agent state. They are the right tool for agent recall. Building Synapse reinforced that autonomous AI requires the exact same rigid, transactional, ACID-compliant data infrastructure that fintech and e-commerce platforms use—just applied to LLM memory nodes.

What's next for Synapse: Transactional Memory Engine for AI Agents

Moving from a REST API to a native Python SDK (pip install synapse-ai) so LangChain and CrewAI developers can plug this in with 3 lines of code. Implementing WebSockets for true bi-directional agent streaming, and adding Row-Level Security (RLS) in DSQL for multi-tenant enterprise isolation.

Built With

  • acid-compliance
  • ai-agents
  • amazon-aurora-dsql
  • aws-sdk-v3
  • b2b
  • developer-tools
  • dynamodb
  • edge-computing
  • knowledge-graph
  • llm-memory
  • next.js
  • node.js
  • react-flow
  • real-time-data
  • saas
  • serverless
  • shadcn/ui
  • tailwind-css
  • typescript
  • v0
  • vercel
Share this project:

Updates