# GraphyLoop (npm · graphyloop)

Workflow planner, wave dispatcher, persistent swarm memory, and deploy preflight for AI agents.

- Trust score: 79/100 (medium)
- Change this week: +14
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `graphyloop`: 79/100 (this document), [markdown](https://verifymcp.io/servers/chadixearth-graphyloop/graphyloop.md), [page](https://verifymcp.io/servers/chadixearth-graphyloop/graphyloop)

## Channel facts

- Registry: `npm`
- Package: `graphyloop`
- Version: `0.6.5`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to chadixearth/graphyloop).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 74/100
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 1596 tokens (~106/item across 15 items; 15 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 23/100
  - Stability observed for 7 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "memory_forget" implies "delete" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 15 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 20/100
  - Spec-recency check failed: implements MCP spec 2024-11-05; the latest is 2026-07-28.

## Install

### How do I install the GraphyLoop MCP server?

GraphyLoop runs locally as an npm package, launched with npx -y graphyloop mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add chadixearth-graphyloop -- npx -y graphyloop mcp
```

### Cursor

```json
{
  "mcpServers": {
    "chadixearth-graphyloop": {
      "command": "npx",
      "args": [
        "-y",
        "graphyloop",
        "mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "chadixearth-graphyloop": {
      "command": "npx",
      "args": [
        "-y",
        "graphyloop",
        "mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add chadixearth-graphyloop -- npx -y graphyloop mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "chadixearth-graphyloop": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "graphyloop",
        "mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add chadixearth-graphyloop --command npx --arg -y --arg graphyloop --arg mcp
```

### Hermes

```yaml
mcp_servers:
  chadixearth-graphyloop:
    command: "npx"
    args: ["-y", "graphyloop", "mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "chadixearth-graphyloop": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "graphyloop",
        "mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add chadixearth-graphyloop -t stdio -c npx -a -y graphyloop mcp
```

### Other

```json
{
  "mcpServers": {
    "chadixearth-graphyloop": {
      "command": "npx",
      "args": [
        "-y",
        "graphyloop",
        "mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 79, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-03 (score 78, 0)

- [functional regression] Security disclosure: unverified → fail

### 2026-11-02 (score 78, +1)

- [functional regression] Security disclosure: fail → unverified
- [functional] Package version: 0.6.4 → 0.6.5

### 2026-10-31 (score 77, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-30 (score 76, +11)

- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → pass

### 2026-10-29 (score 65)

First indexed and scored.

## MCP tools (15)

### `agent_spawn` (~129 tokens)

Spawn a swarm agent. type (required): coder|tester|reviewer|architect|explorer|security|coordinator|frontend|data. Optional: id (default auto-generated), capabilities (comma-separated overrides), role (worker|peer|leader).

Input parameters:

- `capabilities` (string): Comma-separated capability overrides
- `id` (string): Custom agent id (default auto-generated)
- `role` (string): worker | peer | leader (default: worker)
- `type` (string, required): Agent type: coder, tester, reviewer, architect, explorer, security, coordinator, frontend, data

### `agent_list` (~22 tokens)

List all swarm agents with type, status, role, and health.

### `task_distribute` (~66 tokens)

Distribute tasks across swarm agents. tasks (required): JSON string array of {id, type, description, priority}. Returns per-task assignments with opencodeAgentType and prompt.

Input parameters:

- `tasks` (string, required): JSON array of {id, type, description, priority} task objects

### `swarm_state` (~28 tokens)

Swarm status: agents, active agents, tasks completed/failed, pending tasks, memory count.

### `task_record` (~84 tokens)

Record a task result and update agent metrics. taskId + status (required; status: completed|failed). Optional: agentId, error.

Input parameters:

- `agentId` (string): Agent id (default: task assigned agent)
- `error` (string): Error message when failed
- `status` (string, required): completed | failed
- `taskId` (string, required): Task id

### `memory_store` (~98 tokens)

Store a memory entry. content (required). Optional: agent (default system), type (decision|pattern|lesson|event|task, default event), metadata (object or JSON string).

Input parameters:

- `agent` (string): Agent id (default: system)
- `content` (string, required): Memory text
- `metadata` (object): Optional metadata object
- `type` (string): decision | pattern | lesson | event | task (default: event)

### `memory_search` (~93 tokens)

Keyword-search stored memories, ranked by match quality with a recency bias. query (required), limit (optional, default 10), type (optional: decision|pattern|lesson|event|task).

Input parameters:

- `limit` (string): Max results (default 10)
- `query` (string, required): Search query
- `type` (string): Only search this memory type: decision | pattern | lesson | event | task

### `memory_forget` (~64 tokens)

Delete one memory entry by id (ids come from memory_search results). Use this to correct a wrong or outdated memory instead of letting it be recalled forever.

Input parameters:

- `id` (string, required): Memory id to delete, e.g. mem-1700000000000-ab12

### `plan_feature` (~320 tokens)

Plan a multi-layer feature as parallel waves before writing any code. goal (required): the request in plain words, e.g. "inventory system with stock levels, a dashboard and deploy to vercel". Returns wave 0 (the driver, or ONE agent when the code is unmapped, freezes the contract: schema + API + props + test scenarios, AND the context pack ctx-<slug>.md next to it: per lane path:line + current code excerpt + pattern to copy) -> wave 1 parallel builders (data, backend, frontend, tests; the driver keeps the most coupled lane) -> wave 2 integration -> wave 3 parallel verifiers (test, typecheck, security, performance, review) -> wave 4 gated deploy, with per-task file ownership, acceptance checks and dependsOn. Every lane brief ends with the turn-economy footer (batch reads, first edit by turn 5, no project-wide lint/test/build). A goal with no data/backend/frontend/pipeline signal answers shape no-fanout; work touching 8 known files or fewer (inlineThreshold 8) is done inline unless it splits into 2+ independent slices of about 5 minutes each. Pass the returned tasks array (JSON) straight to task_distribute.

Input parameters:

- `goal` (string, required): The feature request, verbatim
- `includeDeploy` (boolean): Force the deploy wave on even if the goal does not mention shipping
- `maxParallel` (string): Local builder concurrency cap (default 4, RAM-bound)

### `secrets_status` (~95 tokens)

Masked readiness report for the project credentials (Supabase, Vercel): which keys are set, where each one comes from (process env, graphyloop store, .env file), and what is still missing. Values are NEVER returned — only a mask. Call this before database or deploy work instead of asking the user to paste keys.

Input parameters:

- `provider` (string): supabase | vercel | all (default all)

### `secrets_set` (~145 tokens)

Store one credential in the project-local secret store (<project>/.graphyloop/secrets.json, chmod 600, git-ignored before the first write). key (required) e.g. SUPABASE_URL, SUPABASE_ANON_KEY, SUPABASE_SERVICE_ROLE_KEY, VERCEL_TOKEN. value (required) is written to disk and echoed back masked only. Use this once per key, then env_sync.

Input parameters:

- `key` (string, required): UPPER_SNAKE_CASE key name
- `provider` (string): supabase | vercel (optional; inferred from the key)
- `value` (string, required): The credential value (stored, never echoed back)

### `env_sync` (~147 tokens)

Write the stored credentials into the env file the framework actually reads (default .env.local), add the framework public aliases for public keys only (NEXT_PUBLIC_*/VITE_*, never for a service-role key), refresh a values-free .env.example, and make sure .gitignore covers the env files. Values move file-to-file: the result lists key NAMES, never values.

Input parameters:

- `force` (boolean): Overwrite a key that already has a different value (a timestamped backup is kept)
- `providers` (string): Comma-separated provider filter, e.g. "supabase"
- `target` (string): Env file name inside the project (default .env.local)

### `preflight` (~100 tokens)

Readiness check + ordered command plan for database setup and/or deploy. target: db | deploy | all (default all). Returns the detected stack, blockers (missing credentials, no build script, env file not git-ignored), warnings, and the exact commands to run — every destructive step (db push, --prod deploy) carries the approval gate it needs. Executes nothing itself.

Input parameters:

- `target` (string): db | deploy | all (default all)

### `skills_status` (~180 tokens)

Which skills are actually installed on this machine (project .opencode/skills, .dsh/skills, .agents/skills; ~/.config/opencode/skills, ~/.claude/skills, ~/.dsh/skills, ~/.omp/agent/skills, ~/.gemini/skills, ~/.agents/skills). Reports the graphyloop-bundled skills (70, of which 12 are graphyloop-authored: graphyloop-waves, graphyloop-workflow, api-contract-design, api-hardening, frontend-security, web-accessibility, web-performance, dependency-audit, supabase-setup, vercel-deploy, secrets-hygiene, swarm-memory) and which skills the squad routes on but are missing. Call it before claiming a skill was used — a missing skill is stated in one line, never faked.

### `shutdown` (~25 tokens)

Shut down the swarm (terminates agents, keeps memory) and exit the MCP server.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/chadixearth-graphyloop/graphyloop#diagnostics

## Score history

- 2026-11-05: 79
- 2026-11-04: 79
- 2026-11-03: 78
- 2026-11-02: 78
- 2026-11-01: 77
- 2026-10-31: 77
- 2026-10-30: 76
- 2026-10-29: 65

## Common questions

### What is the GraphyLoop MCP server?

GraphyLoop is an MCP server listed in the public MCP registry as io.github.chadixearth/graphyloop. Workflow planner, wave dispatcher, persistent swarm memory, and deploy preflight for AI agents. This page covers its npm package (graphyloop).

### Is the GraphyLoop MCP server safe to use?

GraphyLoop scores 79 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the GraphyLoop MCP server expose?

GraphyLoop exposes 15 tools: agent_spawn, agent_list, task_distribute, swarm_state, task_record, and 10 more. Their descriptions and schemas cost roughly 1,596 tokens of context every time the server is loaded.

### Is the GraphyLoop MCP server still maintained?

GraphyLoop is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the GraphyLoop MCP server under?

GraphyLoop declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the GraphyLoop MCP server?

VerifyMCP ran 16 checks on GraphyLoop, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/graphyloop
- Socket report: https://socket.dev/npm/package/graphyloop
- Repository: https://github.com/chadixearth/graphyloop
- Website: https://chadixearth.github.io/graphyloop/
- Changelog RSS feed: https://verifymcp.io/servers/chadixearth-graphyloop/graphyloop.xml
- Changelog JSON feed: https://verifymcp.io/servers/chadixearth-graphyloop/graphyloop/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/chadixearth-graphyloop/graphyloop.json
- HTML version of this page: https://verifymcp.io/servers/chadixearth-graphyloop/graphyloop