PaperPlanes

Inspiration

Every team building AI agents faces the exact same wall: Context Degradation. The industry is obsessed with building massive 1-million token context windows, but there is a fatal difference between how much data an LLM can hold and how well it processes it. Shoving 50 research papers into a standard vector database doesn't give an AI better memory—it creates a noisy, contradictory mess where old facts get permanently overwritten or blindly appended. We realized that for complex, agentic AI, memory cannot just be a bolted-on vector database. Memory has to be the product itself.

What it does

PaperPlanes is a stateful research assistant built on a bi-temporal memory layer. It ingests dense research papers, extracts core claims using AWS Bedrock, and builds a living knowledge graph. When it encounters contradicting facts across different papers, it doesn't hallucinate or delete the old data. Instead, it flags the facts as disputed—holding the tension. Users can interact with the agent via chat, and the agent uses a CockroachDB Managed MCP Server to dynamically write read-only SQL queries to introspect its own memory state.

How we built it

Instead of building another simple RAG pipeline, we synthesized the memory architectures of 6 groundbreaking academic papers (including Zep, Mem0, and CoALA) and engineered them into a single production engine.

• Database: CockroachDB. We leveraged its C-SPANN distributed vector indexing for fast retrieval, and its bi-temporal capabilities (valid_at / invalid_at schema).
• AI Models: AWS Bedrock. We used Amazon Nova Pro for claim extraction and reasoning, and Titan Embeddings for vectorization.
• Agent Logic: Built using LangGraph in Python (FastAPI backend) to handle concurrent memory reflection and Ebbinghaus retrieval.
• Frontend: A custom React (Vite) interface styled in a "Swiss Brutalist" aesthetic to emphasize the technical nature of the engine.

Challenges we ran into

Our biggest hurdle was Zero Data Loss under Concurrency. When you have background reflection workers and active chat agents trying to write to memory simultaneously, standard databases drop writes or cause race conditions. By leveraging CockroachDB's SERIALIZABLE isolation, we ran 25 concurrent agent writers against a single memory node. 58 transaction collisions were detected, gracefully auto-retried in the background, resulting in 0 lost writes.

Accomplishments that we're proud of

We are incredibly proud of our Time Travel Simulator. Because CockroachDB never deletes knowledge, we built a UI slider that uses SELECT * FROM memory_notes AS OF SYSTEM TIME queries. You can literally drag a slider back in time to see exactly what the AI believed last week before it ingested a contradicting research paper.

What we learned

We learned that advanced retrieval isn't just about cosine similarity; it requires decay. We successfully implemented an Ebbinghaus decay algorithm into our retrieval logic, utilizing the mathematical formula:

$$R = e^{-\frac{t}{S}}$$

Where retention ($R$) decays over time ($t$) unless the memory strength ($S$) is reinforced by frequent agent access.

What's next for PaperPlanes

Moving from raw statement embeddings to canonical entity-based matching (Knowledge Graphs) to better detect cross-domain contradictions automatically without human-in-the-loop verification.

Built With

• aws-bedrock
• cockroachdb
• fastapi
• langgraph
• machine-learning
• mcp-server
• postgresql
• python
• react
• vector-search