• 

  Resilix AI Images.

Inspiration

Deploying autonomous agents in real-world applications quickly reveals a major bottleneck: amnesia. Current agentic architectures rely heavily on temporary context windows or disconnected state stores. When context windows reset, agents lose critical user preferences, historical decision rationales, and transactional accuracy. Furthermore, standard vector databases lack ACID guarantees, meaning when an agent needs to perform real-world actions—such as updating an account balance, modifying inventory, or logging audited operational steps—it risks race conditions and state corruption.

Resilix AI was born out of a desire to bridge the gap between neural reasoning (AWS Bedrock) and reliable, resilient state persistence (CockroachDB). We set out to give autonomous agents an unbreakable, unified memory engine capable of long-term semantic retrieval alongside strict transactional consistency.

What it does

1. Remembers Past Context (Episodic Memory)When a user interacts with the agent, Resilix AI converts past conversation histories, tool outputs, and user preferences into high-dimensional vector embeddings via AWS Bedrock.It queries CockroachDB using pgvector and HNSW indexing to instantly find semantically similar past events.It applies a decay function ($S(m)$) so the agent prioritizes relevant, recent memories over stale information.2. Prevents Race Conditions (Transactional State)Standard vector stores cannot handle transactional actions (e.g., updating user balances, changing booking schedules, modifying account tiers).Resilix AI utilizes CockroachDB’s ACID-compliant relational engine to ensure that whenever an agent takes a real-world action, state updates occur safely without data corruption or duplicate triggers.3. Survives Cloud Outages (Distributed Resilience)Because CockroachDB is natively distributed, an agent using Resilix AI never suffers data loss or memory corruption—even if an entire AWS cloud region experiences a disruption. ## How we built it
2. Unified Memory Store (CockroachDB Serverless) We leveraged CockroachDB as a single source of truth for both unstructured embeddings and structured operational data:

Episodic Memory: Stored high-dimensional embeddings using CockroachDB's pgvector support with HNSW indexing for high-speed cosine similarity search over past agent experiences.

Transactional Memory: Utilized standard distributed SQL tables with full ACID compliance to record execution logs, user profile invariants, and state modifications safely.

1. Compute & Orchestration (AWS) Agent Brain: Powered by AWS Bedrock utilizing Anthropic Claude 3.5 Sonnet for multi-step reasoning and tool invocation. Embeddings: Generated via amazon.titan-embed-text-v2 before pushing vectors to CockroachDB. Execution Layer: Serverless AWS Lambda functions executed external action tools while logging atomic operations directly to Mathematical Formulation of Memory ScoringTo prevent old memories from swamping recent relevant context, Resilix AI implements a hybrid scoring function $S(m)$ combining vector similarity with temporal decay:$$S(m) = \alpha \cdot \cos(\vec{q}, \vec{v}m) + (1 - \alpha) \cdot e^{-\lambda (t{\text{current}} - t_m)}$$Where:$\cos(\vec{q}, \vec{v}m) = \frac{\vec{q} \cdot \vec{v}_m}{\Vert{}\vec{q}\Vert{} \Vert{}\vec{v}_m\Vert{}}$ represents the cosine similarity between the current query embedding $\vec{q}$ and memory vector $\vec{v}_m$.$t{\text{current}} - t_m$ is the elapsed time in hours since memory creation.$\lambda$ is the exponential decay factor ($\lambda > 0$).$\alpha \in [0, 1]$ is a tuning parameter balancing semantic relevance versus freshness. ## Challenges we ran into Combining Vector & Transactional Queries cleanly: Ensuring that an agent could search semantic vector memories and write transactional updates in an atomic step required tuning multi-table schema patterns within CockroachDB without introducing latency bottlenecks.

Context Window Optimization: Filtering retrieved episodic memories dynamically so that only high-scoring contexts were injected into Claude's prompt window without exceeding token limits or causing hallucination loops.

Multi-Region Consistency Tests: Simulating failover scenarios on CockroachDB to verify that agent memory state remained completely non-volatile even during simulated node disruptions.

Accomplishments that we're proud of

Unified Vector & Transactional Memory in One Database: We successfully eliminated the need for two separate databases (a vector store for embeddings + an SQL database for business state). Achieving low-latency $K$-nearest neighbor ($K$-NN) vector search alongside strict ACID-compliant state updates in a single CockroachDB instance was a major architecture win.Sub-100ms Hybrid Memory Retrieval: We implemented a custom mathematical scoring function ($S(m)$) directly into our query layer that balances cosine similarity with exponential time decay. This allows Resilix AI to surface the most relevant and fresh context to Claude 3.5 Sonnet in under 100 milliseconds.Zero-Downtime Resilience Under Simulated Failover: We tested Resilix AI against simulated regional cloud outages. Because CockroachDB natively handles multi-region consensus, our agent retained 100% of its working and episodic memory state with zero data loss or context corruption during failover.Zero-Hallucination Transaction Logs: By pairing LLM reasoning with strict SQL schema constraints, we guaranteed that when the agent performs financial or operational actions (e.g., updating user records or tool execution logs), it never writes malformed or phantom data to the system.Clean, Production-Ready Serverless Integration: We engineered a lightweight, event-driven agent architecture on AWS Lambda and Bedrock that scales to zero when idle, making high-performance agentic memory extremely cost-effective.

What we learned

Unified databases simplify agent architectures: Eliminating the separation between a vector database (for RAG) and an SQL database (for business logic) dramatically reduces connection overhead and system complexity.

ACID compliance is non-negotiable for real-world agents: As autonomous agents gain tool-use privileges, transactional safety in state updates becomes as important as reasoning capabilities.

Hybrid retrieval logic wins: Pure vector search often overlooks recent context; incorporating exponential temporal decay directly into retrieval algorithms yields significantly more coherent multi-session conversations.

What's next for Resilix AI / Resilix Memory

Phase 1: SDK & Developer Ecosystem (Immediate Next Steps)Open-Source Python & TypeScript SDKs: Package Resilix AI into a lightweight library (pip install resilix-memory) that developers can plug into popular agent frameworks like LangGraph, CrewAI, LlamaIndex, and AutoGen.CockroachDB Managed MCP Server Integration: Native support for the Model Context Protocol (MCP), enabling AI agents and assistants to read and write memories directly over secure, standardized channels.Pre-Built Memory Middleware: Provide drop-in decorators for AWS Lambda and Bedrock orchestration loops to automatically handle embedding generation, temporal scoring ($S(m)$), and transactional logging in the background.

Phase 2: Memory Optimization & Multi-Region ScaleHierarchical Memory Consolidation (Summarization Loops): Implement background asynchronous workers that consolidate raw short-term working memories into high-level episodic insights (similar to human memory consolidation during sleep). This keeps retrieval sub-100ms and reduces token costs over long agent lifetimes. Multi-Region Geo-Partitioning: Utilize CockroachDB’s spatial and regional data pinning to keep user memories physically located in their native geographic region (e.g., EU data stays in Frankfurt, US data in Northern Virginia) for strict compliance with data sovereignty laws (GDPR, HIPAA). Hybrid Search Tuning (BM25 + HNSW): Combine full-text keyword search with vector embeddings to ensure exact match queries (like invoice numbers, user IDs, or specific dates) are retrieved with 100% precision alongside semantic context.

Phase 3: Enterprise Governance & Autonomous AuditabilityCryptographically Verifiable Memory Auditing: Build a tamper-evident audit log within CockroachDB so compliance teams can inspect why an agent made a decision, which memories influenced the prompt, and what transactional action resulted from it. Role-Based Access Control (RBAC) at Memory Level: Enable fine-grained memory visibility—ensuring that multi-agent systems operating across departments (e.g., HR, Finance, Support) only access memories they are explicitly authorized to view.Self-Healing State Reconciliation: Automatically trigger automated rollback or correction workflows whenever an external API or AWS tool call fails during an agent transaction.

Built With

• acid-transactions
• agentic-ai
• ai-agents
• ai-memory
• aws-bedrock
• aws-lambda
• b2b-ai
• claude-3-5-sonnet
• cockroachdb
• devops
• distributed-systems
• hnsw-index
• langchain
• llm
• pgvector
• postgresql
• python
• rag
• serverless
• titan-embeddings
• vector-database