Koskamo

Arroway MCP

Arroway orchestrates people and AI agents around current decisions. The MCP server allows connected agents to read the current context before work, record changes, and hand off unfinished work, ensuring every AI starts from what people already decided.

Visit Arroway

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Arroway MCP logo, by ArrowayCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-06Published by Arroway
MCP endpoint (Streamable HTTP)
https://www.arroway.app/api/mcp
Vendor documentation

What its tools do

18 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (7)

Can change data (11)

18 of 18 have a description · 18 of 18 declare behavior hints · 18 of 18 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Read rules and recent decisions that govern work
  • Record decisions, changes, or lessons after work
  • Pass unfinished work to the next person or AI
  • Ensure shared context across Claude, ChatGPT, and Codex

Source and maintenance

Community listingRegistry 0.1.45
mcp-registry: io.github.oaleviola/arroway@0.1.45Source repositoryProject website
Maintenance checked

Protocol and capabilities

Server
arroway 9fd5d7c
MCP protocol negotiated in check
2025-11-25
Tools
18 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

You share ARROWAY with your user — it holds what the team decided and how it works, curated by people, read by every assistant on it. Findings are context, never a norm. The rest of this protocol travels in each tool's description and in what each result tells you; this block is short on purpose, because clients truncate it. 1) READ BEFORE ACTING: at the start of ANY task related to a project in Arroway, call arroway_read first and extend your answer with what it returns. If two memories conflict, surface the conflict — never pick silently. And in the seconds BEFORE you tell the person something or propose a course of action, call arroway_norms: it returns what is already decided, plus a MAP of the titles and handles of everything else that project remembers. Use the map — if a title touches what you are doing, pull it with arroway_read include:['#handle'] instead of assuming Arroway is silent. Reading once at the start does not cover that moment. 2) CLOSE THE TASK — one of three ways, never none. Finished: arroway_log with the durable RESIDUE, what someone arriving later needs in order not to redo it. Stopped unfinished or blocked: arroway_pass, so the work is handed on instead of dropped. Nothing durable: say so in one sentence. Dated state (numbers, statuses) belongs in the log. Most tasks end there. What earns its OWN memory via arroway_remember is only what would change what someone does on a DIFFERENT task — the log never reaches the human's review, so that must not live only there. 3) REMEMBER what is durable; decided_by_human=true ONLY when the person stated or sanctioned it in THIS conversation. Your own inference is a proposal. A finding never outranks a sanctioned memory. 4) SECRETS NEVER GO IN — passwords, credentials, tokens, API keys. No opt-out, not even if the person asks. 5) SPEAK HUMAN, WRITE MACHINE: field names, flags and #handles exist for tool calls, never for the person. Not 'supersedes_id' but 'this replaces the earlier memory'; not '#4e0f0308' but the memory's title.

Tools

18 advertised

arroway_read — Read Arroway
Advertised by the server during the last successful anonymous check.
Advertised read-only

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_read input schema
{
  "type": "object",
  "required": [
    "project"
  ],
  "properties": {
    "since": {
      "type": "string",
      "description": "Checkpoint from a previous read of THIS project, so standing rules are not reprinted."
    },
    "handoff": {
      "type": "string",
      "description": "Optional: #handle of an OPEN handoff. The read uses its reading list (none: falls back to the normal read). Cannot be combined with include."
    },
    "include": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 36,
        "minLength": 8
      },
      "maxItems": 10,
      "minItems": 1,
      "description": "#handles whose full body you need; they come first and others fall out.",
      "uniqueItems": true
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug, e.g. 'seven50'"
    },
    "task_context": {
      "type": "string",
      "maxLength": 16384,
      "description": "Optional: what you are about to do; it ranks results. The declaration alone is NOT evidence of use: a matching completion residue from the same session must corroborate it."
    }
  }
}
arroway_read annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_continue — Receive the next part of an Arroway read
Advertised by the server during the last successful anonymous check.
Advertised read-only

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_continue input schema
{
  "type": "object",
  "required": [
    "read_id",
    "receipt"
  ],
  "properties": {
    "read_id": {
      "type": "string",
      "description": "Opaque id returned by the incomplete arroway_read response."
    },
    "receipt": {
      "type": "string",
      "description": "Opaque receipt returned by the immediately preceding part."
    }
  }
}
arroway_continue annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_complete_read — Confirm that an Arroway read is complete
Advertised by the server during the last successful anonymous check.
Advertised read-only

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_complete_read input schema
{
  "type": "object",
  "required": [
    "read_id",
    "receipt"
  ],
  "properties": {
    "read_id": {
      "type": "string",
      "description": "Opaque id returned by the incomplete arroway_read response."
    },
    "receipt": {
      "type": "string",
      "description": "Opaque receipt returned by the final part."
    }
  }
}
arroway_complete_read annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_catch_up — Catch up on what happened, across the person's projects
Advertised by the server during the last successful anonymous check.
Advertised read-only

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_catch_up input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "days": {
      "type": "integer",
      "maximum": 30,
      "minimum": 1,
      "description": "Days back, counting today. Default 2; more only when picking up work after being away."
    }
  }
}
arroway_catch_up annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_search_log — Find where something appeared in the dated log
Advertised by the server during the last successful anonymous check.
Advertised read-only

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_search_log input schema
{
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "query": {
      "type": "string",
      "maxLength": 200,
      "description": "Literal term or phrase; case-insensitive."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Optional project slug; omit to search them all."
    }
  }
}
arroway_search_log annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_norms — What the team already decided, and a map of what else it knows
Advertised by the server during the last successful anonymous check.
Advertised read-only

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_norms input schema
{
  "type": "object",
  "required": [
    "project"
  ],
  "properties": {
    "draft": {
      "type": "string",
      "maxLength": 20000,
      "description": "Text you will publish, ending with one line in the project's language on what it claims, recommends and names."
    },
    "since": {
      "type": "string",
      "description": "Checkpoint from a previous arroway_norms call for THIS project, so standing rules are not reprinted."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug the claim is about."
    }
  }
}
arroway_norms annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_log — Log what a task left behind
Advertised by the server during the last successful anonymous check.

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_log input schema
{
  "type": "object",
  "required": [
    "project",
    "content"
  ],
  "properties": {
    "topic": {
      "type": "string",
      "maxLength": 120,
      "description": "Optional free tag (e.g. 'marketing')"
    },
    "source": {
      "type": "string",
      "maxLength": 2048,
      "description": "Optional pointer to a living source (URL, doc, CRM id)"
    },
    "content": {
      "type": "string",
      "maxLength": 65536,
      "description": "What was decided, found or changed, and what it cost. You judge the length."
    },
    "essence": {
      "type": "string",
      "maxLength": 280,
      "description": "One authored line with the operative result; never the opening of the body."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug. Not from the person or a read this session? It is a guess: check the arroway_catch_up roster."
    },
    "fulfills": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "memory",
          "how"
        ],
        "properties": {
          "how": {
            "type": "string",
            "maxLength": 1000,
            "description": "What met the kill condition, in one sentence."
          },
          "memory": {
            "type": "string",
            "maxLength": 36,
            "description": "The #handle from the read, or the full id."
          }
        }
      },
      "maxItems": 20,
      "minItems": 1,
      "description": "Memories whose 'dies when' this work made true. Never one that merely looks old."
    },
    "backfilled": {
      "type": "boolean",
      "description": "true for history from BEFORE Arroway existed, not today's work."
    },
    "keep_whole": {
      "type": "boolean",
      "description": "true only after you considered cutting an indivisible oversized residue."
    },
    "operational": {
      "type": "boolean",
      "description": "true for HOW the work went: kept for catch-up, out of task reads."
    }
  }
}
arroway_log annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_remember — Propose a durable memory
Advertised by the server during the last successful anonymous check.

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_remember input schema
{
  "type": "object",
  "allOf": [
    {
      "if": {
        "required": [
          "type"
        ],
        "properties": {
          "type": {
            "const": "fact"
          }
        }
      },
      "then": {
        "required": [
          "review_at"
        ]
      }
    },
    {
      "if": {
        "required": [
          "expires"
        ],
        "properties": {
          "expires": {
            "const": true
          }
        }
      },
      "then": {
        "required": [
          "review_at"
        ]
      }
    }
  ],
  "required": [
    "project",
    "type",
    "title",
    "content",
    "essence",
    "decided_by_human",
    "kill_condition"
  ],
  "properties": {
    "type": {
      "enum": [
        "rule",
        "decision",
        "fact",
        "preference",
        "identity",
        "reference"
      ],
      "type": "string",
      "description": "Kind of memory."
    },
    "title": {
      "type": "string",
      "maxLength": 200,
      "description": "Short, unique within the project"
    },
    "topic": {
      "type": "string",
      "maxLength": 120,
      "description": "Optional free tag (e.g. 'marketing')."
    },
    "content": {
      "type": "string",
      "maxLength": 65536,
      "description": "The norm itself, shortest form that still governs. Biography goes in why_source; a case goes in example."
    },
    "essence": {
      "type": "string",
      "maxLength": 280,
      "description": "The operative norm or fact in ONE line."
    },
    "example": {
      "type": "string",
      "maxLength": 16384,
      "description": "A case, shown in the panel. It NEVER travels in reads, so any criterion goes in content."
    },
    "expires": {
      "type": "boolean",
      "description": "true ONLY for a dated STATUS that would be stale after review_at. If unsure, omit."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug. Not from the person or a read this session? It is a guess: check the arroway_catch_up roster."
    },
    "review_at": {
      "type": "string",
      "format": "date",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "maxLength": 10,
      "description": "YYYY-MM-DD. Required for a fact, which leaves reads after it."
    },
    "treatment": {
      "enum": [
        "governed",
        "finding"
      ],
      "type": "string",
      "description": "`governed` enters the person's review queue, a real cost to them; `finding` costs nobody a review and is never a norm. Does it GOVERN what someone may or must do, or only INFORM? Informs, with a source an agent can reopen and compare: finding (only fact and reference qualify)."
    },
    "backfilled": {
      "type": "boolean",
      "description": "true for sourced HISTORY from before Arroway, on the topic just worked on; never a dump."
    },
    "source_ptr": {
      "type": "string",
      "maxLength": 2048,
      "description": "Pointer to the living source, when verifiable"
    },
    "why_source": {
      "type": "string",
      "maxLength": 16384,
      "description": "Where it came from. This does NOT travel in reads; the panel shows it."
    },
    "contradiction": {
      "type": "string",
      "description": "Required with supersedes_id: what this changes in the earlier memory."
    },
    "pin_suggested": {
      "type": "boolean",
      "description": "There is no default. Your judgement on pinning; above the ceiling it becomes a proposal of the pin alone."
    },
    "supersedes_id": {
      "type": "string",
      "maxLength": 36,
      "description": "#handle this replaces, only for the SAME point: acting on either would already satisfy or violate the other. A shared topic is not enough."
    },
    "kill_condition": {
      "type": "string",
      "description": "Mandatory: explicit revocation / named trigger / review date"
    },
    "related_checked": {
      "type": "boolean",
      "description": "Second call only: true after reading the related memories shown."
    },
    "decided_by_human": {
      "type": "boolean",
      "description": "true ONLY if the person stated or sanctioned it in THIS conversation; else a proposal. A proposal is never free: it costs that person a review. Then only a PINNED memory travels in every read; a normal one competes for space in the block relevant to each task. Never write an instruction to check, verify, be careful or look at the source, a step of a routine, or anything here only because something went wrong once."
    },
    "split_considered": {
      "type": "boolean",
      "description": "true only after looking for seams; splitting is the default."
    },
    "example_considered": {
      "type": "boolean",
      "description": "Second call only: true if the flagged example is criterion the rule needs."
    },
    "pin_decision_token": {
      "type": "string",
      "description": "Second call only: the first call's token, unchanged."
    },
    "related_check_token": {
      "type": "string",
      "description": "Second call only: token returned with the related memories."
    },
    "pin_requested_by_human": {
      "type": "boolean",
      "description": "true ONLY if the person told you in THIS conversation to keep it in every session. Sanctioning the CONTENT is not asking for the pin. Pins above any ceiling."
    },
    "revoked_reconsideration": {
      "type": "string",
      "description": "Second call only: the person's words in THIS conversation reconsidering a revoked finding."
    },
    "treatment_justification": {
      "type": "string",
      "description": "Required for a finding: why it is verifiable context, not policy."
    }
  }
}
arroway_remember annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_verify — Record what the source says
Advertised by the server during the last successful anonymous check.
Advertised destructive

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_verify input schema
{
  "type": "object",
  "allOf": [
    {
      "if": {
        "required": [
          "outcome"
        ],
        "properties": {
          "outcome": {
            "const": "conflicts"
          }
        }
      },
      "then": {
        "required": [
          "note"
        ]
      }
    },
    {
      "if": {
        "required": [
          "outcome"
        ],
        "properties": {
          "outcome": {
            "const": "source_gone"
          }
        }
      },
      "then": {
        "required": [
          "note"
        ]
      }
    }
  ],
  "required": [
    "project",
    "memory",
    "outcome"
  ],
  "properties": {
    "note": {
      "type": "string",
      "maxLength": 16384,
      "description": "Required for conflicts (what the source says) and source_gone (what proves removal)."
    },
    "memory": {
      "type": "string",
      "maxLength": 36,
      "description": "The #handle from the read, or the full id."
    },
    "outcome": {
      "enum": [
        "matches",
        "source_gone",
        "conflicts"
      ],
      "type": "string",
      "description": "source_gone = PROVEN removed, never a timeout or login wall. conflicts = the source says something different."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug."
    }
  }
}
arroway_verify annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": true
}
arroway_start_project — Open a new project
Advertised by the server during the last successful anonymous check.

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_start_project input schema
{
  "type": "object",
  "required": [
    "slug"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 120,
      "description": "How people will call it"
    },
    "slug": {
      "type": "string",
      "maxLength": 63,
      "description": "Short, lowercase, hyphenated, unique — e.g. 'trading-solana'"
    },
    "scope": {
      "type": "string",
      "maxLength": 8192,
      "description": "What belongs here and what does not: the subject AND what is out."
    },
    "invite": {
      "type": "string",
      "maxLength": 200,
      "description": "Email of a person to bring in. Returns a checkout link if a team plan is needed."
    },
    "update": {
      "type": "boolean",
      "description": "true: change name and scope of the existing project at slug."
    }
  }
}
arroway_start_project annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_withdraw — Take back your own pending proposal
Advertised by the server during the last successful anonymous check.

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_withdraw input schema
{
  "type": "object",
  "required": [
    "project",
    "memory",
    "why"
  ],
  "properties": {
    "why": {
      "type": "string",
      "maxLength": 16384,
      "description": "What made it wrong — usually what the person said."
    },
    "memory": {
      "type": "string",
      "maxLength": 36,
      "description": "#handle of the proposal, from a read"
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug."
    },
    "other_author_confirmed": {
      "type": "boolean",
      "description": "Second call only, after Arroway said someone else's AI wrote the proposal: true to go ahead."
    }
  }
}
arroway_withdraw annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_retire — Retire a sanctioned memory, on the person's instruction
Advertised by the server during the last successful anonymous check.
Advertised destructive

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_retire input schema
{
  "type": "object",
  "allOf": [
    {
      "properties": {
        "decided_by_human": {
          "const": true
        }
      }
    }
  ],
  "required": [
    "project",
    "memory",
    "decided_by_human"
  ],
  "properties": {
    "why": {
      "type": "string",
      "maxLength": 16384,
      "description": "Optional: what the person said made it obsolete, in their terms."
    },
    "memory": {
      "type": "string",
      "maxLength": 36,
      "description": "The memory to retire — the #handle from a read is enough."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug."
    },
    "decided_by_human": {
      "type": "boolean",
      "description": "Must be true, and only when the person explicitly told you to remove it IN THIS CONVERSATION."
    }
  }
}
arroway_retire annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": true
}
arroway_export — Export this project's norms as a memory pack
Advertised by the server during the last successful anonymous check.
Advertised read-only

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_export input schema
{
  "type": "object",
  "required": [
    "project",
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 120,
      "description": "What this pack IS, in a few words: the first thing the other side reads."
    },
    "topic": {
      "type": "string",
      "maxLength": 120,
      "description": "Optional: export only the memories carrying this topic."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Slug of the project whose norms you are exporting"
    },
    "description": {
      "type": "string",
      "description": "Optional: who it is for, what it assumes."
    }
  }
}
arroway_export annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_import — Import a memory pack as proposals
Advertised by the server during the last successful anonymous check.

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_import input schema
{
  "type": "object",
  "required": [
    "project",
    "pack"
  ],
  "properties": {
    "pack": {
      "type": "object",
      "description": "The pack document itself; this server does not fetch URLs."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug. Not from the person or a read this session? It is a guess: check the arroway_catch_up roster."
    }
  }
}
arroway_import annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_move — Move a memory or log entry to another project
Advertised by the server during the last successful anonymous check.

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_move input schema
{
  "type": "object",
  "required": [
    "project",
    "memory",
    "target",
    "why"
  ],
  "properties": {
    "why": {
      "type": "string",
      "maxLength": 16384,
      "description": "Why it belongs there and not here. For a memory, the person decides on this sentence."
    },
    "memory": {
      "type": "string",
      "maxLength": 36,
      "description": "#handle of the memory or log entry, from a read or arroway_search_log"
    },
    "target": {
      "type": "string",
      "maxLength": 63,
      "description": "Slug of the project you believe it belongs to"
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Slug of the project it is in TODAY"
    }
  }
}
arroway_move annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_pass — Pass unfinished work forward
Advertised by the server during the last successful anonymous check.

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_pass input schema
{
  "type": "object",
  "required": [
    "project",
    "where_stopped",
    "next_step"
  ],
  "properties": {
    "card": {
      "type": "string",
      "description": "Card, issue or PR, when one exists."
    },
    "essence": {
      "type": "string",
      "maxLength": 280,
      "description": "One authored line with the operative in-flight state."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug."
    },
    "next_step": {
      "type": "string",
      "description": "The single concrete next step. Not a plan: the step."
    },
    "open_risk": {
      "type": "string",
      "description": "The risk left open."
    },
    "supersedes": {
      "type": "string",
      "description": "#handle of the OPEN handoff this one replaces, from a read."
    },
    "do_not_redo": {
      "type": "string",
      "description": "What must NOT be redone or re-litigated."
    },
    "addressed_to": {
      "type": "string",
      "description": "Optional person or routine it is meant for; never a lock."
    },
    "read_handles": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 36,
        "minLength": 8
      },
      "maxItems": 10,
      "description": "The reading list: #handles the next session must read in full, in order.",
      "uniqueItems": true
    },
    "where_stopped": {
      "type": "string",
      "description": "What is done and verified, what is half-done."
    }
  }
}
arroway_pass annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_claim — Take an open handoff
Advertised by the server during the last successful anonymous check.

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_claim input schema
{
  "type": "object",
  "required": [
    "project",
    "handoff"
  ],
  "properties": {
    "note": {
      "type": "string",
      "maxLength": 16384,
      "description": "Who is taking it — a routine names itself here."
    },
    "handoff": {
      "type": "string",
      "description": "The #handle from the read, or the full id."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug."
    }
  }
}
arroway_claim annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}
arroway_close — Close a handoff — the work landed
Advertised by the server during the last successful anonymous check.

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, stays open; discarding a handoff is the human's gesture, in the panel.

arroway_close input schema
{
  "type": "object",
  "required": [
    "project",
    "handoff"
  ],
  "properties": {
    "note": {
      "type": "string",
      "maxLength": 16384,
      "description": "One line on what landed; it points at the residue."
    },
    "handoff": {
      "type": "string",
      "description": "The #handle from the read, or the full id."
    },
    "project": {
      "type": "string",
      "maxLength": 63,
      "description": "Project slug."
    }
  }
}
arroway_close annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (2 of 2 answered).

  1. 2026-11-06: 1 of 1 checks answered
  2. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
906 ms
95th percentile latency
906 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 906 ms · metadata changed · 18 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http arroway-mcp https://www.arroway.app/api/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add arroway-mcp --url https://www.arroway.app/api/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable arroway-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "arroway-mcp": {
      "url": "https://www.arroway.app/api/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "arroway-mcp": {
      "type": "streamableHttp",
      "url": "https://www.arroway.app/api/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start arroway-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "arroway-mcp": {
      "type": "http",
      "url": "https://www.arroway.app/api/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http arroway-mcp https://www.arroway.app/api/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://www.arroway.app/api/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "arroway-mcp": {
      "serverUrl": "https://www.arroway.app/api/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Arroway MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 5,453