Goose Memory Across Sessions and Agents

goose connects to MemoryRouter as a remote MCP extension. You add the Streamable HTTP endpoint, complete OAuth in the browser, and goose gets tools to search and store memories in your MemoryRouter vault. The vault lives outside goose, so what you stored is still there after auto-compaction, after /compact, and in a new session.

The same vault is reachable from Claude Code, Codex, ChatGPT, and Claude. A decision stored from goose can be recalled in any of them, and the other way around.

This is a remote MCP extension, not a built-in goose extension or a goose plugin. There is no hook package for goose today, so recall and capture are model-directed: goose decides when to call the tools.

How this fits with goose's own memory

goose ships several local context tools, and MemoryRouter does not replace them:

• goosehints. A global ~/.config/goose/.goosehints file and project .goosehints files hold instructions goose reads every session.
• Memory extension. A built-in extension that stores categorized notes as files in .goose/memory/ for a project or ~/.config/goose/memory/ globally.
• Chat Recall extension. A built-in, off-by-default extension that searches your past goose sessions on this machine.

Those stay on one machine and inside goose. Keep hints for how goose should work. Use MemoryRouter when you want the record of the work, such as decisions, reasoning, and rejected approaches, in one vault that a fresh goose session and your other agents can all search.

Prerequisites

• goose Desktop or the goose CLI, installed and configured with a provider.
• A MemoryRouter account and a vault you are allowed to use.
• A local browser for the OAuth step. goose serves the callback on 127.0.0.1.

You do not need a model-provider API key in MemoryRouter for this setup. goose keeps using its own provider.

Add the extension

goose Desktop

1. Open the sidebar and click Extensions.
2. Click Add custom extension.
3. Set Type to Streamable HTTP, Extension Name to MemoryRouter, and Endpoint to https://mcp.memoryrouter.ai/mcp.
4. Click Add.

goose CLI

Run goose configure, choose Add Extension, then Remote Extension (Streamable HTTP). Name it memoryrouter and enter https://mcp.memoryrouter.ai/mcp as the URL.

Config file

You can also add it to ~/.config/goose/config.yaml (%APPDATA%\Block\goose\config\config.yaml on Windows) under extensions:

extensions:
  memoryrouter:
    type: streamable_http
    name: memoryrouter
    enabled: true
    uri: "https://mcp.memoryrouter.ai/mcp"
    timeout: 300

Leave out client_id and scopes. goose obtains a client identity automatically, and its config only accepts scopes together with a pre-registered client_id.

Do not add a Memory Key under headers. The MCP server accepts OAuth access tokens, not mk_ keys.

To try it for one session without saving the extension, start goose with goose session --with-streamable-http-extension "https://mcp.memoryrouter.ai/mcp".

Authenticate

goose can load the extension and list its tools before you sign in. The first time it calls a memory tool, MemoryRouter answers with an authorization challenge and goose opens your browser. Sign in, review the permissions on the consent screen, and choose the vault this extension should use. goose identifies itself with its client metadata document, so there is no client ID to paste.

goose asks only for the scope the current call needs. If the first call is a search, it gets memories:read. The first save then opens one more consent screen to add memories:write. Delete and consolidation tools ask for their own scopes the same way, so nothing beyond what you approve in the browser is ever granted. MemoryRouter scopes are independent, so a read and write connection cannot erase your vault.

goose stores the credentials in its secret store under the extension's name and refreshes them on later sessions. One OAuth connection is bound to one vault. To use a second vault, add the same endpoint again under a different name, such as memoryrouter-work, and choose that vault when the browser opens.

Make recall a habit

Tool calls are model-directed. A short note in .goosehints makes recall and capture more consistent without guaranteeing a call on every turn:

Memory: at the start of a task, search MemoryRouter for earlier decisions about this project.
When I say "remember this", store it in MemoryRouter as one concise memory.

Cross-session proof

Use a synthetic fact, not source code or secrets.

1. In a goose session, ask: "Store this in MemoryRouter: the demo project's release phrase is ORCHID-7419." Approve the store_memory call if prompted and check that it succeeded.
2. End the session, or run /compact, so the fact is no longer in the active context.
3. Start a new session and ask: "Search MemoryRouter for the demo project's release phrase." Do not include the answer.
4. Confirm the search_memories result contains ORCHID-7419. Check the tool result, not only goose's reply.
5. Optional: ask the same question from Claude Code, Codex, or ChatGPT connected to the same vault.

This is a test you run in your own account. Recall is relevance-ranked over the vault, not a dump of every memory on every request.

What goose can do

With memories:read and memories:write, goose can use search_memories, date_search_memories, inspect_memory, memory_status, the search alias, and store_memory. The MCP server reference lists every tool, its inputs, and the scope it requires. Use available_tools in the extension config if you want to expose fewer of them.

About the custom provider route

goose can also route model traffic through an OpenAI-compatible custom provider, and MemoryRouter has an OpenAI-compatible endpoint. That route is not documented here. The proxy stores and recalls message text and does not guarantee tool-calling parity, which an agent like goose depends on. Use the extension above, which keeps goose on its normal provider.

Limitations

• Capture is model-directed. Nothing is stored unless goose calls store_memory, and nothing is recalled unless it calls a search tool.
• Connecting does not import earlier goose sessions, .goosehints, or files from the built-in Memory extension.
• OAuth needs a local browser on the machine running goose.
• A shared vault is shared. Use a separate vault and a separate extension connection when projects or people must stay isolated.

Troubleshooting

Disabling or removing the extension stops future tool calls. It does not delete memories already in the vault. See security and data isolation for deletion.

Next steps

• MCP server reference: tools, scopes, and vaults
• goose memory overview
• Coding tools guide
• goose extension documentation
• Create a MemoryRouter account