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.
The old failure mode: human decisions buried in Slack. The new failure mode, growing every day: decisions locked in human–AI conversation threads nobody else will ever read. Two engineers, two agents, two contradictory choices made on the same Tuesday afternoon.
Conventions and procedures live in READMEs that were accurate six months ago. For AI coding agents, stale docs aren't friction. They're fatal.
Two agents work on related features simultaneously with no mechanism to share context. Neither knows the other exists.
The bottleneck in modern software development is no longer writing code. It's making decisions, and making sure everyone knows what was decided, why, and what it means for the work ahead.
Software teams are humans and AI coding agents now, working in parallel, often without seeing each other's work. Memex AI is designed for both from the ground up.
Define strategies, make decisions, and articulate the why machines can't infer from code.
One source of truth that both humans and machines read and write to.
Agents act on what was actually decided, not what they hallucinate from stale docs.
Not a human tool with an API bolted on. Not an AI tool with a dashboard bolted on.
One graph. Two interfaces. Zero drift.
You are not redundant. You are the chef.
AI is the sharpest knife you've ever held.
Our roles in software are evolving. Our humanity is not.
The grind is lifting. The tedium is collapsing. What's left is the part that was always the point: deciding what to build, why it matters, and whether it's any good.
Memex is built around that belief. Every primitive exists to keep the knives sharp and out of your way — so your attention goes to the part only the chef can do.
Four primitives describe the work. One describes the people doing it. Together they form a single graph every human and every agent reads from and writes to.
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.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 have goals, acceptance criteria, and explicit dependencies on other items and decisions. When scope expands, a work item gets promoted to its own strategy, with full lineage preserved.
WI-1 ← WI-2, WI-3 │ WI-3 ← D7, D8 │ WI-4 ← WI-1, WI-3Scoped, prescriptive rules: not "here's how auth works" but "when you modify auth, do X, never do Y, verify with Z." Every rule is provenance-tracked — each one links back to the decision that produced it, so you can always see why the blueprint says what it says.
deployment [CURRENT] testing [DRIFT DETECTED]Humans aren't "whoever happens to be logged in" — they're an explicit primitive in the graph, connected to every other one. Memex watches who creates which strategies, who resolves which kinds of decisions, who writes which blueprints, whose reviews catch the issues that matter. Over time it builds a picture of who holds what, and routes the right decisions to the right people, automatically.
@sarah owns auth · @alex owns deployment · @priya owns design-systemIn the old world, planning happens in a separate universe from implementation. Someone writes a spec in a doc, shares it in Slack, it goes through a review cycle, and eventually an engineer reads a half-stale document and starts coding from an incomplete understanding of the intent.
In Memex, you build the strategy inside your coding tool, through conversation, grounded in the actual codebase. The agent that helps you draft it is the same agent that will pick up the first work item.
You articulate the problem. The agent reads relevant code, drafts the purpose statement. You push back. The purpose sharpens with each pass.
As the approach comes together, the agent recognises non-obvious choices. It creates draft decisions with options and trade-offs for you to resolve.
The agent reads the codebase to understand what exists, what needs changing, and what the dependency order should be. Then proposes work items.
Existing blueprints are linked to relevant work items. New blueprints are scoped where gaps exist. Publish, and the graph goes live.
Memex AI doesn't just store knowledge. It actively detects when things go wrong and surfaces decisions you'd otherwise miss.
The single most effective quality gate for AI coding agents.
The feature that kills the wiki.
Nobody will log them manually.
Memex AI is an MCP server. Any AI agent connects to the same decision graph through standard tool calls — your coding agent, a research agent investigating open decisions, a testing agent verifying completed work, a custom agent you built this afternoon. One protocol, one graph, every agent.
Works with Claude Code · Cursor · GitHub Copilot · Windsurf · Custom agents · any MCP-compatible tool
Add Memex AI to your agent's MCP config and the entire decision graph is available. No plugins, no vendor lock-in.
claude_desktop_config.jsonThese track who's doing what. Memex AI tracks what was decided, why, and what agents need to know before touching the code.
Wikis have no drift detection, no provenance, and no scope boundaries. Memex AI blueprints are living documents with automated freshness guarantees.
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.
Point Memex at your Notion, your repo, or your Confluence. It reads what's there, drafts your first strategy, and surfaces the decisions already buried in your existing docs. Ready in minutes, not a migration.
Any MCP-compatible agent — Claude Code, Cursor, Copilot, Windsurf — plugs in with a few lines of config. From the next session, it reads the graph before writing code.
Agents load context, check decisions, submit execution plans for review. You approve, they implement. Drift detection starts day one.
Strategy, architectural decisions, security processes, unreleased product thinking, internal blueprints — all connected in one graph. That's the point. It also means self-hosting can't be an enterprise checkbox. It's a core design principle.
Sign up, connect an agent, start building. The simplest path to getting your team onto Memex. Best for teams who want zero operational footprint.
Memex ships as a single Docker container against any Postgres 15+ database. No Kubernetes cluster. No service mesh. No outbound calls for your graph, your decisions, or your blueprints.
If your codebase lives in your infrastructure, your Memex should be able to live there too. We've built the product so that's never a trade-off against functionality.
Managed by us. Start building in minutes.
Your infrastructure. Your data. Your LLM keys.
Docker + PostgreSQL 15+
Software tooling always follows the bottleneck.
AI coding 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.
Mindset AI is the agentic platform powering in-app AI agents at a growing list of B2B SaaS companies. Every engineer on our team works with coding agents daily. Our product people design in conversation with AI. Our support team uses AI to triage and respond. We aren't just building AI agents — we're running an AI-native company.
When we started, we assumed the hardest part of AI-assisted engineering would be code quality. It wasn't. Modern coding agents produce good code when they know what they're trying to build.
The hard part turned out to be context. Two engineers, each with their own agent, arriving at contradictory decisions. An agent loading a wiki that was last updated two quarters ago. A re-prioritisation that silently invalidates half the decisions that shaped the previous plan.
We run Mindset on a set of mental models that take bottlenecks seriously. One of them is the Theorem of Constraints: any interconnected process operates at the speed of its slowest part. We're allergic to bottlenecks in our own organisation, and we look for them constantly.
When we applied that lens to AI-assisted development, the bottleneck was unmistakable: it wasn't writing code, it was capturing, propagating, and maintaining decisions across humans and agents.
Memex AI is the system we built to remove that bottleneck. It started as internal infrastructure. We use it every day. It's now the decision layer behind everything Mindset builds — and Memex itself runs on the Mindset agentic platform, so the product you're looking at is a working example of what both can do together.
Memex AI is in early access for teams already building with AI coding agents.
Because the hardest part of building software was never writing the code.