Integration

Long-term memory for Goose

Goose is Block's local-first agent: extensible, opinionated, and fast. Its current remote-MCP extension type is `streamable_http`, and Engram's hosted MCP endpoint is SSE-only today, so the cleanest path is `mcp-remote` as a stdio→SSE bridge. The plugin sets that up in one extension block, and npm handles the bridge.

Get an API key (free) All integrations →

Install

Three steps: sign up for an Engram API key, paste a BYOK LLM-provider key on /models, then drop the snippet below into Goose.

Three steps to memory in your agent

Sign up. Free, no card. You'll land on a Getting Started page that walks the next two steps.
Add your LLM key. Engram is BYOK. Paste an OpenAI / Anthropic / Groq / Together / Fireworks key and we'll route every extraction and query call through your provider. You pay your provider directly. We never see your inference.
Paste the snippet below into your agent and restart it. Use Authorization: Bearer <api-key>with the API key from your portal.

engram-goose-extension: Goose extension

Routes through mcp-remote (stdio→SSE bridge) since Goose dropped first-party SSE in 1.34+. Source: github.com/lumetra-io/engram-goose-extension.

Export your API key (Goose reads env_keys from the keyring):

Terminal

export ENGRAM_API_KEY="<api-key>"

Add the extension block to ~/.config/goose/config.yaml:

~/.config/goose/config.yaml

extensions:
  engram:
    type: stdio
    name: engram
    description: "Lumetra Engram: durable memory for agents."
    cmd: npx
    args:
      - "-y"
      - "mcp-remote"
      - "https://mcp.lumetra.io/mcp/sse"
      - "--transport"
      - "sse-only"
      - "--header"
      - "Authorization:Bearer ${ENGRAM_API_KEY}"
    env_keys:
      - ENGRAM_API_KEY
    timeout: 120
    enabled: true
    bundled: false

Start a session with goose session. The six Engram tools appear alongside Goose's built-ins; the mcp-remote bridge is auto-installed by npx on first launch.

What you can do once memory's wired in

Persist Goose's understanding of a long-running engineering task across sessions
Recall the decisions Goose made when running autonomously overnight
Run Goose in a multi-agent flow where each agent shares Engram as the team memory
Capture the user preferences Goose has learned and reuse them across new tasks

FAQ

Why is `mcp-remote` involved?

Goose's current remote-MCP extension type is `streamable_http`. Engram's hosted MCP at `mcp.lumetra.io/mcp/sse` is currently SSE-only, so `mcp-remote` is the cleanest path: a tiny stdio↔SSE bridge that the extension shells out to via `npx`.

Will I need to install the bridge manually?

No. `npx -y mcp-remote ...` runs it on demand: the first invocation downloads the package, and subsequent runs use the cache. There's no global npm install needed.

What happens when Engram ships native Streamable HTTP?

The extension config simplifies to a direct `url` + `headers` form (already in the README as the forward-compatible variant). The bridge disappears, and the rest of the setup is unchanged.

Related integrations

Ship durable memory in Goose today

Free tier: 10K memories and 50K retrievals per month. No credit card. Same Engram backend powers all 41 integrations, so memories you write from one client are immediately queryable from the rest.

Start free See pricing