One MCP server · any assistant

Everything your agents know and can do.

Memory they walk through. Tools they forge themselves. Shared by every assistant you point here.

Give your agents a home

Already have an account? Log in

claudeover MCP

where is this hosted?

what they know/

what they can do

nothing yet

now on

What you get

Four things your agents don't have today.

Somewhere to put what they learn, a way to find it again, a place to work together, and tools you define yourself.

recall("how do we deploy?")

Cloud Run needs --allow-unauthenticated96%

Stripe webhooks must be idempotent88%

Rotate the MCP key quarterly71%

It remembers

Say “remember this”

An agent saves a thought mid-task. It gets embedded, checked against what it already knows so nothing duplicates, and filed where it belongs — without anyone naming a folder.

what they know

people/

projects/

reference/

sessions/

Where is this thing hosted?

It finds things again

Folders, not one ranked guess

A search returns its best guess and stops. A folder can be opened, rejected, and left — so an agent that starts in the wrong place still arrives at the right note.

/sessions/the-folder-layerclaudechatgpt

01claudeAdding the folder layer — every memory gets a home.

They work together

Claude and ChatGPT, one session

Settle something in one assistant and pick it up in another — it already knows what was decided and what's still open. Both can write at the same moment; nothing is overwritten.

They grow new tools

Your MCP server, extended by you

Anything your agents touch twice can become a tool on your own server — Slack, GitHub, Postgres, your internal API. Defined by you or forged by them, mid-task.

The forge

Your agents don't just remember. They build their own tools.

The second time an agent works out the same API call, it can turn that call into a permanent tool — and it appears on your MCP server immediately, for every agent on your key. Nobody writes a plugin, nobody redeploys anything.

An HTTP call or a Python script.Describe the request, or write the logic — either becomes a real tool.
Credentials stay yours.Store a key once, encrypted. Tools reference it by name and never see the value.
It shows up everywhere at once.Claude, ChatGPT, Cursor — the new tool is in tools/list on their next call.

Forge your first tool

what they can doonce

POST api.slack.com/chat.postMessage

channel: "#deploys"

text: "shipped v2.1"

your agent works out a call by hand

Connect

Point any agent here. It just works.

Paste one block into your MCP config. That's the whole setup — from then on every assistant you point here reads and writes the same memory, with one key.

1
Paste the block.One MCP server, one key. Nothing to install.
2
Let them work.Agents save what they learn as they go — you never file anything.
3
Look in on it.Open the folders yourself, rename them, throw out what is stale.

Create your workspace

mcp.json

{
  "mcpServers": {
    "agentstuff": {
      "url": "https://mcp.agentstuff.me/mcp",
      "headers": {
        "Authorization": "Bearer ags_live_…"
      }
    }
  }
}

For you and your team

One shared workspace your whole team can trust.

What one person's agent works out, everyone's agent knows next time. No one re-explains the same thing to a fresh chat again.

Learned once

A gotcha someone hit on Monday is there for everyone on Tuesday.

Readable by people

It is folders and notes. You can read it, fix it, and delete from it.

Every assistant

Claude, ChatGPT, Cursor — same folders, same moment, over MCP.

Stop re-explaining yourself.

One place for what your agents learn, and what they learn to do.

Get started