Atlas

Inspiration

Startup knowledge lives in Slack threads, Notion pages, decks, and people's heads. Those tools store what was decided — none of them remember why, or how the thinking changed along the way. When someone leaves, the reasoning leaves with them. And every "AI with memory" we looked at answers from the latest snapshot: it can tell you what's true now, but ask "why did we change our mind?" and it guesses.

That gap became our thesis: memory that is time-aware and append-only — where beliefs have a history, and the history is the product.

Live demo: https://atlas-agentic-memory.streamlit.app/

What it does

Atlas is a team of AI agents with one shared, versioned memory. Every belief change is a new record — with its cause, trigger, and tension (what it traded off against) — never an overwrite. Ask any question and three domain-constrained agents (Finance, Product, Strategy) each ground themselves in that history; Finance and Product run in parallel, then Strategy synthesizes and, when it reaches a new conclusion, writes it back into memory. Upload a messy meeting transcript (PDF, Word, Markdown, text, or PowerPoint) and a distiller agent compresses it into structured decision records — the original staged in Amazon S3 (auto-created bucket) for provenance. A provenance timeline shows every topic as revisions: superseded beliefs struck through in red pencil, never erased.

How we built it

We're a two-person team, both new to the agentic-AI domain, so we split by interface contract: one of us owned the data layer (CockroachDB schema, embeddings, retrieval tools), the other owned agents and UI — each building against agreed function signatures, with mocks until integration day. The final swap was one import line.

The memory is two-tier: a compact memory_index of tag embeddings under an HNSW index, pointing at full decisions rows. Agents call search and fetch as separate typed tools — retrieval strategy is a model decision, not a hardcoded pipeline. A decision row and its index row commit in a single CockroachDB transaction — one database holding both relational and vector data means a searchable pointer can never drift from its record. The specialist agents run in parallel on a thread pool over pooled connections, and the UI streams a live trace of every search, fetch, and write-back.

Tech stack:

Database: CockroachDB Serverless
Embeddings: CockroachDB (Distributed Vector Embedding)
LLM: Gemini (gemini-flash-lite-latest)
Object storage: Amazon S3
Frontend: Streamlit (4 pages: Chat, Timeline, Ingest, About)

Challenges we ran into

The AWS saga. Our brand-new account sat in verification for days; then Bedrock's Claude — and even Amazon's own Nova — turned out to require a paid Marketplace subscription our free credits couldn't satisfy, and Titan embeddings were throttled to unusable. Three dead ends, each diagnosed by reading actual error codes. We pivoted the LLM and embeddings to Gemini behind a provider seam (Bedrock remains a drop-in swap) and kept AWS in the stack with S3 document staging.

Embedding invariants. Stored vectors and query vectors must come from the same model at the same dimension — and HNSW indexes cap out near 2000 dimensions, so we truncate Gemini's 3072-dim embeddings to 1536 (Matryoshka) to keep the index valid.

Agents misbehaving. An empty search sent our agent into a loop of rewording queries forever. The fix taught us the golden rule: prompt guidance for the normal case, hard code guardrails (loop caps, forced final answers, tool-error feedback) for when the model doesn't listen.

Provider dialects. Gemini has no tool role — function results go back as user. Its flagship free tier is 20 requests/day. Small facts, hours of debugging.

Accomplishments that we're proud of

A genuinely agentic loop — the model chooses when to search, what to fetch, and when to record — closing the full store → retrieve → act cycle, with the agent's own conclusions becoming queryable history.
Atomic dual-writes: no possible drift between a record and its search pointer.
Document ingestion that distills instead of summarizes — cause, trigger, and tension survive compression as structured fields.
Shipping through three AWS dead ends without losing the week — the provider seam meant the pivot cost one file.
A distinctive drafting-sheet UI where superseded beliefs are struck through in red pencil but never erased — the product thesis, drawn.
Parallel multi-agent execution — Finance and Product agents run concurrently, cutting answer latency by roughly a third.

What we learned

Tool use is the line between a chatbot and an agent. Calibrate from measurements, not intuition. Never trust a model to follow instructions without a code guardrail behind it. And an interface contract lets two beginners build in parallel without ever blocking each other.

What's next for Atlas

Swapping the seam back to Bedrock on a funded account, real Slack/Notion ingestion, multi-tenancy, and impact scoring on decisions — so Atlas can answer not just "why did we change our mind?" but "which changes mattered most?"