The memory layer for engineering organizations

MemoryWorks remembers every incident, decision, owner, and dependency your team already learned — and briefs people and AI agents before they change something.

  • Cited every fact links to its source
  • Time-aware old truths kept, not overwritten
  • Approved people authorize what agents change

Learns from the tools your team already uses · briefs the agents you already run

  • GitHub
  • Slack
  • Google Drive
  • Notion
  • Microsoft Teams
  • PDFs & docs
  • Websites
  • Claude Code
  • Cursor
  • VS Code
  • Claude
  • ChatGPT
  • Python SDK
  • CLI
  • MCP
Before it acts

Your agent is about to change something your team has changed before.

Before it acts, it asks MemoryWorks. The answer isn’t a list of search results. It names the constraint the change would break, the outage it would repeat, and whether to stop and get a person.

  • One call before any consequential change
  • A verdict: proceed, proceed with context, or requires approval
  • Every line cited to the source it came from
agent › rotate the token signing keys→ get_orgmemory_briefing(task=rotate the token signing keys, service=auth-service)
MemoryWorks briefingRequires approval

Rotating keys signs out clients that still cache the old one.

Prior incident
Last rotation signed out every mobile session for 40 minutes
Constraint
Publish the new key 24 hours before signing with it
Owner
Identity team — on-call approves rotations
  • Postmortem · token rotation
  • GitHub · PR #412
  • Slack · #identity
What it does

One memory, for the people and the agents doing the work.

Source-backed, time-aware memory

Code, pull requests, threads, and documents become one memory. Every fact points to where it came from — and when something changes, the old truth is kept and marked superseded, not overwritten.

A verdict, not search results

Every briefing ends in a call an agent can act on.

  • Proceednothing on record says wait
  • With contextgo ahead, knowing this
  • Requires approvala person decides
  • No memorynothing known — not a yes

Owners, as of today

Who owns a service now, who did before, and who to wake up.

Impact before change

What else a change touches: services, shared databases, downstream jobs.

Learns from outcomes

Each briefing’s result is recorded, so the next one knows what worked.

How it fits

Everything your team knows, wired to every agent that acts on it.

Sources become kinds of memory; memory briefs the agents; outcomes flow back in. Drag the graph, or hover a node to see what it carries.

The memoryMemoryWorks

One time-aware memory, every fact tied to its source.

  • Sources
  • Memory
  • Agents
The loop

Context served, action taken, outcome observed.

Anyone can index the same Slack and the same repositories. What only your workspace builds up is the record of which context actually led to the right action.

  1. 01 · BriefContext served

    The agent says what it is about to do and gets back the incidents, decisions, and constraints that apply — each with its source.

  2. 02 · DecideA person approves

    Anything consequential waits for a human: inline in the chat, or in Approvals. The verdict is advice, never authorization.

  3. 03 · ActAction taken

    The agent does the work in the editor or tool it already runs in. MemoryWorks never acts on its own.

  4. 04 · RecordOutcome observed

    What happened goes back into memory, so the next briefing knows what worked and what didn't.

Built for developers

Plug it into the agents you already run.

An MCP server for assistants, a Python SDK and CLI for everything else, and the same API underneath.

  1. 1
    Connect a sourceSign in with GitHub and your repositories are ready to pick. Add Slack, Drive, Notion, or uploads.
  2. 2
    Issue a workspace keyScoped to one workspace, for CLIs, SDKs, and MCP clients.
  3. 3
    Agents ask before they actOne briefing call before a consequential change; one outcome call after.
Read the docs
mcp.json
{
  "mcpServers": {
    "memoryworks": {
      "command": "mcp_server/.venv/bin/python",
      "args": ["mcp_server/server.py", "--transport", "stdio"],
      "env": {
        "MEMORYWORKS_API_URL": "https://memoryworks.app",
        "MEMORYWORKS_API_KEY": "om_live_..."
      }
    }
  }
}
Safe by design

Agents investigate. People authorize.

Nothing changes without a person

Agents can read, cross-check, and propose. Changes to memory or a connected tool wait for approval.

Source permissions carry through

People and agents only see what the underlying source already lets them see.

Credentials stay on the server

OAuth tokens never reach the browser or a model.

Every answer cites its source

Each line links to the memory and the pull request, thread, or document behind it.

What does your team already know?

Connect one source and ask. Sign in with GitHub and your repositories are ready to pick.

⌘K
Try