Axiom

Axiom gives AI a memory for decisions, remembering why they were made, what assumptions they depend on, and when changing reality means it’s time to reconsider.

Comment

Inspiration

Important technical decisions rarely fail because teams forget what they decided. They fail because teams forget why.

An architecture may have been chosen because traffic was expected to stay below a certain threshold, costs were assumed to remain within budget, or a particular constraint existed at the time. Months later, those assumptions change, but the decision remains.

That inspired Axiom.

I wanted to explore a different form of agentic memory: not memory that simply helps an AI remember previous conversations, but memory that preserves reasoning, assumptions, and invalidation conditions and can actively influence future behavior.

The question behind Axiom became:

What if an agent could remember why a decision was valid—and recognize when it no longer is?

What it does

Axiom is an agentic decision-intelligence platform that transforms technical decisions into living organizational memory.

When a user submits a decision, Axiom uses Amazon Bedrock to extract:

  • the decision itself
  • its rationale
  • underlying assumptions
  • conditions that would invalidate those assumptions
  • confidence

Axiom then persists this structured memory in CockroachDB Cloud and generates a 1024-dimensional semantic representation using Amazon Titan Text Embeddings V2.

When new evidence arrives, Axiom retrieves relevant historical memory through vector similarity and evaluates the new evidence against the assumptions behind previous decisions.

For example, a team might decide:

Host Atlas on Render because we expect fewer than 10,000 requests per day and want infrastructure spending below $100 per month.

Later, Axiom receives:

Atlas is now receiving 47,000 requests per day.

Axiom retrieves the original decision and determines:

  • Traffic assumption: INVALIDATES — 100% confidence
  • Pricing assumption: WEAKENS — 85% confidence
  • Decision state: ACTIVE → AT_RISK

The key idea is that Axiom does not retrieve memory merely to generate a better answer.

Persisted memory changes what the agent does.

How I built it

Axiom uses a serverless architecture spanning AWS and CockroachDB Cloud.

AWS Amplify
     |
     v
React + TypeScript + Vite
     |
     v
AWS Lambda Function URL
     |
     v
FastAPI + Mangum
     |
     +-----------------------+
     |                       |
     v                       v
Amazon Bedrock          CockroachDB Cloud
Nova 2 Lite             Transactional Memory
Titan Embeddings V2     VECTOR(1024)
                        Distributed Vector Index
                        Managed MCP Server

Amazon Nova 2 Lite performs structured decision extraction and evaluates assumptions against new evidence.

Amazon Titan Text Embeddings V2 converts decision memory and observations into 1024-dimensional vectors.

CockroachDB Cloud acts as Axiom's durable system of record. It stores decisions, assumptions, observations, evaluations, lifecycle state, and semantic memory.

CockroachDB's vector capabilities allow Axiom to semantically connect new evidence with relevant historical decisions rather than relying only on keyword matching.

I also integrated the CockroachDB Cloud Managed MCP Server with Codex using OAuth and read-only permissions. This provides an independent interface into Axiom's persistent memory. Through MCP, Codex was able to inspect the live database and confirm the same AT_RISK decision, invalidated traffic assumption, and evaluation results produced by the application.

The production frontend is hosted on AWS Amplify, while the FastAPI backend runs serverlessly on AWS Lambda through Mangum.

Agentic memory

The central design principle behind Axiom is that memory should be more than conversation history.

Axiom models several forms of memory:

  • Decision memory — what was decided
  • Rationale memory — why it was decided
  • Assumption memory — what needed to remain true
  • Observation memory — what subsequently happened
  • Evaluation memory — how new evidence affected previous assumptions
  • Semantic memory — vector representations connecting related evidence and decisions

This creates a continuous loop:

Remember
   ↓
Retrieve
   ↓
Reason
   ↓
Evaluate
   ↓
Update state
   ↓
Remember again

The LLM performs semantic reasoning, while deterministic application logic controls authoritative lifecycle transitions such as ACTIVE → AT_RISK.

Challenges I ran into

One major challenge was designing memory that was actually useful to an agent, rather than simply storing chat history.

I had to separate semantic retrieval from authoritative state. Vector similarity determines which historical memories are relevant, but structured relational records remain the source of truth for decisions and evaluations.

Integrating the different infrastructure components also presented challenges.

I worked through CockroachDB TLS certificate verification, Bedrock inference-profile requirements for Nova 2 Lite, Lambda packaging for native Python dependencies, IAM permissions, Function URL authorization and CORS, and finally Amplify artifact deployment.

Another interesting challenge was preventing the model from directly controlling decision state. Axiom allows the model to evaluate evidence, but deterministic application logic decides when an invalidated assumption should transition a decision to AT_RISK.

That separation makes the agentic workflow easier to inspect and reason about.

Accomplishments that I'm proud of

The biggest accomplishment is getting the complete memory lifecycle working end-to-end in production:

Decision
→ structured assumptions
→ persistent memory
→ vector embedding
→ new evidence
→ semantic retrieval
→ assumption evaluation
→ ACTIVE → AT_RISK

I'm also proud that CockroachDB is not simply being used as application storage. Its transactional and vector capabilities form the core of Axiom's memory architecture.

The Managed MCP integration adds another dimension: an external AI client can securely inspect the same durable memory through a standardized protocol.

Finally, I deployed the complete MVP using serverless AWS infrastructure, giving Axiom a working production frontend and API rather than leaving it as a local prototype.

What I learned

Building Axiom changed how I think about AI memory.

Useful agent memory is not necessarily about remembering more. It is about preserving the right structure so that past information can influence future decisions.

I learned that combining relational state with vector retrieval provides a powerful pattern: vectors answer "what previous memory is relevant?", while structured records answer "what is actually true about the system?"

I also gained practical experience integrating Amazon Bedrock models, CockroachDB vector search, Managed MCP, FastAPI, AWS Lambda, IAM, and Amplify into one production workflow.

Most importantly, I learned that persistent memory becomes substantially more interesting when it can trigger reconsideration, rather than just recollection.

What's next for Axiom

The MVP focuses on technical architecture decisions, but the underlying model can extend much further.

Next, I would like Axiom to:

  • continuously ingest evidence from operational systems
  • automatically monitor assumptions over time
  • create an immutable decision-state audit trail
  • notify teams when decisions become at risk
  • recommend whether a decision should be retained, revised, or replaced
  • connect evidence from GitHub, observability platforms, cloud infrastructure, incident systems, and documentation
  • support multiple organizations and projects with stronger access controls
  • expose richer agent capabilities through MCP

The long-term vision is an organizational memory layer where agents don't just know what happened.

They understand why previous decisions made sense, what those decisions depended on, and when reality has changed enough to reconsider them.

Decisions have consequences. Axiom remembers why.

Built With

Share this project:

Updates