Skip to content
MCP server

Arroway

Shared decision memory so people and their AIs start from what the team already decided

Pricing
Freemium
Platforms
API, vscode
Runs
Remotely
Version
0.1.58
Listing updated
3 days ago

About Arroway

Arroway is a freemium MCP server for knowledge and memory. It runs as a hosted remote server, so there is nothing to install locally.

Before acting, a connected assistant reads the rules and recent decisions for the project; when it finishes, it records only what a later person would need to avoid redoing the work. If nothing durable came out of the task, the assistant says so. Proposals from an AI stay separate from decisions a person made until someone approves them, and each decision keeps its owner and source.

Work stopped midway can be handed on: the pass tool leaves where things stand, the single next step, what not to redo and the open risk, and the next assistant takes it with a claim. There is also a catch-up across projects, log search and an explicit remember command for things you state yourself.

The plugin installs for Claude Code, Cowork and Cursor with hooks that make the assistant read first and log at the end, and the connector works in the browser or phone. Agents never count as people for billing.

Install

Run in a terminal

claude mcp add --transport http arroway https://www.arroway.app/api/mcp

Add to Settings → Connectors → Add custom connector

https://www.arroway.app/api/mcp
Install in CursorOpens Cursor, which asks you to confirm. Or add it by hand:

Add to ~/.cursor/mcp.json

{
  "mcpServers": {
    "arroway": {
      "url": "https://www.arroway.app/api/mcp"
    }
  }
}
Install in VS CodeOpens VS Code, which asks you to confirm. Or add it by hand:

Add to .vscode/mcp.json

{
  "servers": {
    "arroway": {
      "type": "http",
      "url": "https://www.arroway.app/api/mcp"
    }
  }
}

Add to ~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "arroway": {
      "serverUrl": "https://www.arroway.app/api/mcp"
    }
  }
}

Add to your client's MCP settings (most use this shape)

{
  "mcpServers": {
    "arroway": {
      "type": "http",
      "url": "https://www.arroway.app/api/mcp"
    }
  }
}

Tools this server provides (18)

Read directly from the server.

arroway_read
Read Arroway for a project BEFORE acting on any task related to it. Name a #handle in include to recover that object's full body.
arroway_continue
Fetch the next part of a read that did not fit (read_id and receipt of the preceding part). Returns the next slice with a new receipt; the part marked complete is the last. OPTIONAL: the first part already counts as delivered.
arroway_complete_read
Acknowledge the final part of a multi-part Arroway read with its read_id and receipt, closing the sequence. It is not a precondition for working.
arroway_catch_up
Call ONCE at the START of a session, before there is a task: recent work across this person's projects, opening with the roster and open handoffs.
arroway_search_log
Find WHERE a literal term appeared in the recent dated log, in one project or all of them. It searches what happened, not curated memory.
arroway_norms
Call in the seconds BEFORE you tell the person something or propose a course of action: returns what is already decided AND THEN A MAP of the titles and handles. arroway_read include GUARANTEES a mapped one in full; it does not make that read any cheaper, so use it to be sure, never to pay less. Before publishing text for others, pass it as draft.
arroway_log
Record the durable residue of a COMPLETED task: what someone arriving later needs in order not to redo it. ALWAYS write the authored essence (only a frozen catalog without that field may omit it). If a read memory's 'dies when' came true, name it in fulfills.
arroway_remember
Save a durable memory (decision/rule/fact/preference/reference/identity) only when it would change a DIFFERENT task. Unsanctioned in THIS conversation, it is a PROPOSAL. 'identity' is WHO someone is: the user's circle goes in their personal project, a business's people in that business's project. A finding cannot replace a sanctioned memory.
arroway_verify
Record what a memory's source says when your work ALREADY took you there — never go verifying memories as a task. A conflicting one: propose the correction with arroway_remember. On a FINDING, source_gone archives it and a conflict is corrected in place.
arroway_start_project
Open a NEW project when the work has no home; it needs slug, name and scope. Propose them to the person FIRST. update=true renames a project you own and rewrites its scope when the person asks or the scope is wrong; the slug stays. invite brings someone in by email.
arroway_withdraw
Take back a pending PROPOSAL that turned out wrong, usually because the person corrected you. Not for sanctioned memories. If the corrected version is durable, also write it with arroway_remember.
arroway_retire
Retire a SANCTIONED memory when the person told you to remove it and nothing replaces it. With a corrected version, use arroway_remember supersedes_id; for your own pending proposal, arroway_withdraw.
arroway_export
Export what a project has DECIDED, as a pack for another project. Only sanctioned, live memories travel: a FINDING never was one, so findings stay and the answer tells you how many did.
arroway_import
Bring a memory pack made by arroway_export INTO a project. Everything lands as a PROPOSAL for the person's review and nothing is pinned, whatever the pack says. If any part is malformed, nothing is imported.
arroway_move
Move something to the project it belongs in. A memory is only PROPOSED: the change waits for the person's review, because moving changes who sees it. A log entry you wrote moves at once, text unchanged.
arroway_pass
Call when you STOP with the task unfinished: it leaves a HANDOFF served at the top of every read until someone closes it; a completed task ends in arroway_log instead. ALWAYS write the authored essence (only a frozen catalog without that field may omit it).
arroway_claim
Mark that you are taking an open handoff BEFORE working on it. A claim is a mark, never a lock. Addressing rule: addressed to YOUR user — take it; to someone else — only a human in this conversation can decide to take it, and an autonomous session must leave it.
arroway_close
Close an open handoff when its work is DONE, alongside the arroway_log entry that records the residue. Work that removes what an open handoff exists to fix closes that handoff in the same pass — even when the handoff is someone else's. So this is also the call for someone ELSE's handoff, with a note naming what emptied it. A handoff that still carries real work, which a passer-by must never close,

What it does

Read before work
Pull current rules and decisions first.
Approve what stands
AI proposals wait for a person's approval.
Handoff
Pass unfinished work with its next step.
Audit history
See who decided what, when and through which AI.
Plugin hooks
Read before changes and record on finish.
Cross-AI
Claude, ChatGPT and Codex read the same decisions.

Good for

  • Stop assistants contradicting a decision made last month
  • Hand a half-finished task to a teammate's AI
  • Catch up on a week across projects
  • Record a pricing rule once for all AIs

Pricing

Freemium, from $19.9 a month

Free for one person; Team US$19.90 per person per month

Prices change. Check arroway.app before you buy.

Arroway FAQ

What does it cost?

Free for one person and US$19.90 per person per month for teams.

Do agents count as people?

No, agents never count as people for billing.

Who approves what an AI proposes?

A person, until then it stays separate from decisions.

Where does it work?

Claude Code, Cowork, Cursor, and as a connector in Claude in the browser or phone.

Is Arroway free?

Arroway has a free plan, with paid plans for more usage or features. Paid plans start at $19.9 a month.

How do I add Arroway to Claude Code?

Run this command in your terminal: claude mcp add --transport http arroway https://www.arroway.app/api/mcp

What are the best alternatives to Arroway?

The closest alternatives to Arroway are Codebase Memory, XERJ, Ha MCP, Claude Code Ultimate Guide and Nautilus Compass Memory.

Alternatives to Arroway

  1. Codebase Memory

    MCP server

    Local MCP server that builds a code knowledge graph for AI coding agents

    Runs locally
    • Open source
    • 48.7K GitHub stars
    • Knowledge and memory
  2. XERJ

    MCP server

    Local search engine for AI agents with cited answers over your code and docs

    Runs locally
    • Open source
    • 19.2K GitHub stars
    • Knowledge and memory
  3. Ha MCP

    MCP server

    MCP server for managing and automating Home Assistant from AI assistants

    Runs locally
    • 8 tools
    • Open source
    • 7.9K GitHub stars
    • Productivity
  4. MCP server for searching the Claude Code Ultimate Guide from any MCP client

    Runs locally
    • Open source
    • 6.5K GitHub stars
    • AI models and LLM tooling
  5. Local-first long-term memory layer for AI agents, served over MCP

    Not checked yet
    • 5 tools
    • Remote
    • Open source
    • 1.3K GitHub stars
    • Knowledge and memory
  6. Concord MCP

    MCP server

    Local-first MCP server for messaging and shared work-state between coding agents

    Runs locally
    • Freemium
    • 1.3K GitHub stars
    • Developer tools