Your AI agents are brilliant.
They're also building the wrong thing.

memex.ai is the strategy, decision, and knowledge layer for AI-native software teams. It gives every agent — and every human — the shared context that turns individually capable into collectively coherent.

Request Early Access See How It Works

memex-cli

// the problem

The world moved on. The tools didn't.

Decisions are invisible — both directions

Human decisions are buried in Slack. Agent decisions are locked in threads. Neither has a canonical record.

#eng-backend 3 weeks ago
"let's go with Valkey instead of Redis"
→ agent builds Redis. PR rejected.

AI planning session yesterday
decided: session tokens, not JWTs
→ locked in a thread. nobody else knows.

Knowledge decays

Conventions and procedures live in READMEs that were accurate six months ago. For AI agents, stale docs aren't friction — they're fatal.

testing-guide.md
last updated: 6 months ago
says: "mock the database"
→ team stopped after prod incident

Agents can't coordinate

Two agents work on related features simultaneously with no mechanism to share context. Neither knows the other exists.

Agent A: modifies auth interface
Agent B: builds against old interface
→ merge conflict. both agents' work wasted.

// human–machine collaboration

Built for the team you actually have.

Software teams are humans and AI agents now — working in parallel, often without seeing each other's work. memex.ai is designed for both from the ground up.

Humans set direction

Define strategies, make decisions, and articulate the why machines can't infer from code.

The shared graph

One source of truth that both humans and machines read and write to.

Agents execute with context

Agents act on what was actually decided — not what they hallucinate from stale docs.

What humans bring

Strategy and intent — the why behind the work
Decisions with rationale that others can trace
Priority judgement when trade-offs have no clear answer
Review of agent-extracted decisions and execution plans
Domain knowledge that doesn't exist in the codebase

What machines bring

Tireless execution against well-defined work items
Automatic extraction of decisions from conversations
Drift detection — flagging when docs diverge from code
Dependency checking before every implementation
Parallel work across the entire codebase, simultaneously

Not a human tool with an API bolted on. Not an AI tool with a dashboard bolted on.
One graph. Two interfaces. Zero drift.

// the model

Four layers. One graph.

Strategy — the objective

The container for everything.

A strategy articulates what the team is trying to achieve and why. Not a one-line epic title — the full context that makes every downstream choice intelligible.

Old world: Epic. New world: a living document with reasoning, constraints, and context that agents can navigate.

Decisions — the leading edge

First-class objects, not afterthoughts buried in Slack.

Every non-obvious choice gets an ID, status, options, and rationale. Open decisions block. Resolved decisions constrain. When priorities shift, you re-resolve — and the system traces the impact.

D7: Cache strategy [OPEN] D3: Auth approach [RESOLVED]

Work Items — the dependency graph

Not a backlog. A DAG.

Work items have goals, acceptance criteria, and explicit dependencies on other items and decisions. The system knows what's ready, what's blocked, and why.

WI-1 ← WI-2, WI-3 │ WI-3 ← D7, D8 │ WI-4 ← WI-1, WI-3

Blueprints — the trailing edge

Institutional knowledge that can't rot.

Scoped, prescriptive instructions: not "here's how auth works" but "when you modify auth, do X, never do Y, verify with Z." Every blueprint traces to the decisions that produced it.

deployment [CURRENT] testing [DRIFT DETECTED]

// intelligent features

The system works for you.

memex.ai doesn't just store knowledge — it actively detects when things go wrong and surfaces decisions you'd otherwise miss.

Drift detection

The feature that kills the wiki.

Agent-reported: agents flag blueprint/code mismatches during execution planning
Decision-triggered: resolved decisions auto-mark affected blueprints for review
Implementation-triggered: completed work items prompt blueprint review
Scheduled audits: continuous automated comparison, not quarterly

deployment [CURRENT] testing [DRIFT DETECTED]

Decision extraction

Nobody will log them manually.

Passive extraction: decisions surfaced automatically when sessions end
Decision bundles: batched with summary, rationale, and source link
Review like a diff: approve, reject, or flag — progressive disclosure
Merge into the graph: approved decisions become first-class objects

3 decisions extracted → 2 approved, 1 flagged

// architecture

MCP-native. Connect any agent.

memex.ai is an MCP server — any AI agent connects to the same decision graph through standard tool calls.

mcp-tools

# Strategy (top-level container) list_strategies() → all strategies with status summary get_strategy(id) → purpose, vision, decisions, work items promote_work_item(wi_id) → elevate a WI to its own strategy # Decisions (within a strategy) get_decision(id) → status, options, rationale resolve_decision(id, choice, why) → resolve + cascade impact reopen_decision(id, reason) → re-open, cascade staleness # Work Items (dependency graph) get_ready_work_items(strategy?) → what can start right now submit_execution_plan(wi, plan) → ground truth before coding check_dependencies(wi_id) → met vs blocked, within + across strategies # Blueprints (cross-cutting knowledge) get_blueprint(domain) → scoped context for agents flag_blueprint_drift(id, evidence) → "code says X, blueprint says Y" get_blueprints_for_work_item(wi) → which blueprints to load # Decision Extraction extract_decisions(session_id) → surface decisions from conversations create_decision_bundle(decisions) → batch for review, like a merge request review_bundle(id, actions) → approve / reject / flag per decision

Works with Claude Code · Cursor · GitHub Copilot · Windsurf · Custom agents · any MCP-compatible tool

// works with your tools

One MCP server. Every AI coding tool.

Add memex.ai to your agent's MCP config and the entire decision graph is available — no plugins, no vendor lock-in.

Claude Code

Anthropic

Native MCP support via claude_desktop_config.json

Cursor

Anysphere

MCP servers in Cursor settings

GitHub Copilot

GitHub

MCP support in Copilot Chat & agent mode

Windsurf

Codeium

MCP server configuration in Cascade

Cline

Open Source

Built-in MCP server management

Custom Agents

Any framework

Standard MCP client SDK

agent-workflow

# Agent picks up work via MCP agent → get_ready_work_items(strategy="S3") memex ← WI-2: Profile schema redesign [ready] # Agent loads context before coding agent → get_work_item("WI-2") agent → get_blueprints_for_work_item("WI-2") memex ← blueprints: [data-model, testing] agent → check_dependencies("WI-2") memex ← all dependencies met, 0 blocking decisions # Agent submits plan for review agent → submit_execution_plan("WI-2", plan) memex ← plan queued for review # After approval: agent implements, then reports agent → update_work_item_status("WI-2", "complete") memex ← WI-2 complete → WI-4 unblocked

// why not just use...

Familiar tools. Different era.

vs. Jira / Linear / Shortcut

These track who's doing what. memex.ai tracks what was decided, why, and what agents need to know before touching the code.

vs. Confluence / Notion

Wikis have no drift detection, no provenance, and no scope boundaries. memex.ai blueprints are living documents with automated freshness guarantees.

vs. CLAUDE.md / cursor rules

These validate the need, but they're per-repo, per-tool, and manually maintained. memex.ai is the managed, multi-agent, cross-repository evolution with decisions, dependency graphs, and drift detection.

// get started

Three steps. No migration.

Connect your first agent

Point any MCP-compatible agent at memex.ai — it immediately gains access to your entire decision graph.

Capture your first strategy

Define the objective, log decisions, scope work items, and write blueprints — less time than Jira epics and immediately useful.

Watch the cycle work

Agents load context, check decisions, and produce execution plans — you review, they implement, drift detection starts day one.

// pricing

Simple, transparent pricing.

Cloud

$20/user/month

Managed by us. Start building in minutes.

Get Started

Unlimited strategies, decisions & work items
Blueprint authoring & drift detection
Decision extraction from agent sessions
Full MCP server for all compatible agents
Dependency graph & impact analysis
Multi-agent coordination
Team collaboration & permissions
Cloud CDN & automatic backups
Email & chat support

Self-Hosted

Custom

Your infrastructure. Your data. Your LLM keys.

Contact Sales

Everything in Cloud, plus:
Deploy on your own infrastructure
Complete data sovereignty
Use your own LLM API keys
SSO & enterprise authentication
Priority support & onboarding

Requires Node.js + PostgreSQL

Software tooling always follows the bottleneck.

AI agents made implementation fast and cheap. The new bottleneck is strategy and decisions — articulating what we're building, resolving ambiguity, and ensuring every agent and every human acts on the same understanding.

memex.ai is the tool for this new bottleneck.

Your AI agents are brilliant.They're also building the wrong thing.