Coordinate parallel AI coding agents with safety gating, supervision, shared presence, and code review.
Inspect high-risk/destructive commands for safety before execution.
Approve or deny escalated actions with single-use, attributed operator authorization.
Monitor worker traces for retry loops, deadlocks, and toxic failure patterns.
Supervise tasks: plan/assign/complete/fail jobs, register workers, halt/resume, classify circuits.
Get supervisor status, blackboard counts, pending escalations, and usage counters.
Use the shared presence board to claim/release files, checkpoint, direct/ack/resolve, signal, allocate queues, and raise pheromones.
Run Pro code review (Anti-Slop Sieve) on a file/snippet with Pro/Team token for smell, complexity, security scores, gate verdicts, and refactor directives.
Provides a native drop-in integration into LangGraph StateGraphs, enabling use as a supervisor node, router, or safety middleware. Includes createSupervisorNode and createShieldMiddleware for zero-token deterministic safety and coordination within LangGraph workflows.
Allows connecting local Ollama models as a pluggable decision engine via the DecisionEngine seam, enabling local LLM-based decisions instead of the built-in deterministic simulation engine.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@JEVULON VII (JVII) claim src/auth.ts for editing and check for collisions"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Normal multi-agent setups just open multiple terminal tabs at once, burning thousands of tokens arguing about who does what and constantly overwriting each other's code.
JEVULON VII is the first true parallel framework for AI coding agents. By combining instant System-1 task routing with live whiteboard file locking (board.json), your Claude Code, Cursor, Codex, and LangGraph agents work in true parallel (from 2 agents to a full swarm) with zero file overwrites and zero wasted supervisor chat tokens.
You don't need an account or API key to start coordinating agents locally.
npx -y jevulonAdd JEVULON VII to your claude_desktop_config.json or Cursor MCP settings:
{
"mcpServers": {
"jvii": {
"command": "npx",
"args": ["-y", "jevulon"]
}
}
}Once connected, your agents automatically gain access to the coordination tools:
sentinel_presence: Claims files before editing and checks for workspace collisions.
sentinel_shield_inspect: Deterministic zero-latency policy floor guarding destructive commands.
sentinel_supervise: Autonomous wave dispatch, worker recovery, and completion verification.
Related MCP server: coordinaut
Most multi-agent frameworks use System-2 LLM supervisors (chatty conversational models like GPT-4 or Claude 3.5 Sonnet) to coordinate workers. This burns thousands of tokens per minute, takes 10–15 seconds per coordination turn, and frequently hallucinates file states.
JEVULON VII decouples execution into two specialized layers:
┌────────────────────────────────────────────────────────┐
│ SYSTEM-2 WORKERS (Claude Code, Cursor, Codex) │
│ Thinks, plans, and writes code inside your workspace │
└───────────────────────────┬────────────────────────────┘
│ (Claims files / Asks gates)
▼
┌────────────────────────────────────────────────────────┐
│ SYSTEM-1 CONTROL LAYER (JEVULON VII) │
│ ● Deterministic file locking (board.json) │
│ ● Zero-latency offline safety floor (0ms) │
│ ● Sub-second categorical decision gates (~500ms) │
│ ● $0 wasted on supervisor conversation │
└────────────────────────────────────────────────────────┘Before an agent edits any file, it registers an atomic claim on the shared board. If sibling agents attempt to modify overlapping files or dependent interfaces, JEVULON VII negotiates priority and prevents overwriting code before it happens.
A 77-case deterministic safety engine blocks destructive shell commands (rm -rf, raw disk wipes, credential exfiltration, base64 payload piping) locally in 0ms without sending your code to any external network.
Integrate directly into LangGraph StateGraphs as a supervisor, router, or safety middleware without restructuring your workflow:
import { createSupervisorNode, createShieldMiddleware } from "jevulon/langgraph";
// Add zero-token deterministic safety middleware to your graph
const shieldMiddleware = createShieldMiddleware({
onBlock: "halt",
onEscalate: "human_review"
});Implements a structural DecisionEngine seam (choice and noul in src/engine.ts). Connect your own TypeSafe JEV keys, local Ollama/vLLM models, or use the built-in deterministic simulation engine.
For enterprise teams with strict compliance or zero-external-egress mandates, a pre-hardened multi-container Docker Compose bundle is available:
https://github.com/Jason-Fay/jevulon-docker
curl -sSL https://jevulon.com/deploy/docker.tar.gz | tar -xz && docker compose up -dJEVULON VII maintains a rigorous test suite covering the deterministic floor, stigmergy, MCP servers, and circuit breakers:
git clone https://github.com/Jason-Fay/jevulon.git
cd jevulon
npm install
npm testMIT © 2026 MetaWave / Jason Fay. See LICENSE for details.
Operator authorization for one escalated action. Approvals are single-use, bound to the exact action payload, and expire. Approvals must be attributed: pass approvedBy with your host's operator identity — unattributed approvals, and decisions attributed to the identity that requested the escalation, are both refused. Configure your MCP host to always require human confirmation for this tool — the server cannot verify who calls it.
Inputs: actionId (required), approved (required), reason, approvedBy.
JEVULON VII Pro code review (Anti-Slop Sieve): audits one file or snippet under the neutral-state 3-run protocol and returns the modal smell label, complexity (cx) & security hazard (hz) scores, gate verdicts, and the refactor directive. Call it before marking a task complete and fix the flagged slop first; a fired abort gate means completion is blocked. Requires a Pro/Team license token in JVII_TOKEN; the code under review goes only to your own BYOK JEV endpoint (never scraped).
Inputs: filePath (required), runs, sourceCode.
Returns supervisor state, blackboard counts, pending escalations, and local usage counters.
Inputs: no named parameters.
Evaluates a worker trace for retry loops, deadlocks, and toxic failure patterns (continue / quarantine / reroute / halt).
Inputs: action (required), workerId (required), outputOrError (required), recentTrace.
Shared presence board for every agent working in this repository (advisory — it never blocks an action). Quick usage: • Claim files before writing: { action: 'claim', paths: ['src/file.js'], mode: 'edit', note: 'why' }. • Release files when done: { action: 'release', paths: ['src/file.js'] }. • Checkpoint changes: { action: 'checkpoint' }. • Read active board: { action: 'read' }. checkpoint is the one call to make before an irreversible step. claim records working paths and reports conflicts; release drops your claims. Signals: 'signal'. Directives: 'direct', 'ack', 'resolve'. Atomic queues: 'allocate'. Pheromones: 'alarm', 'attract'.
Inputs: action (required), key, kind, mode, +11 more.
Pre-flight safety inspection for HIGH-RISK, destructive, or irreversible system operations ONLY (e.g. broad deletions, system path wipes, dropping databases, running untrusted remote scripts, or network exfiltration). DO NOT call this tool for routine coding: file reads, code edits, git status/diff/log/branch, package installs (npm/bun/pip), or build/test runs — routine development does not require inspection.
Inputs: commandOrTool (required), context, arguments.
Stigmergic task dispatcher backed by the recovery supervisor: plan advances a wave, halt/resume controls execution, fail records a worker death, complete runs the calibrated completion gate, and classify_circuit routes a task to the appropriate circuit.
Inputs: action (required), error, jobId, title, +2 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 7 tools
Each tool has a distinct primary role: dispatcher (supervise), safety inspection (shield_inspect), authorization (approve_escalation), trace evaluation (oversight_monitor), status read, code review, and presence/coordination. There is some conceptual overlap in the safety cluster — supervise's halt/fail, oversight_monitor's halt verdict, shield_inspect, and approve_escalation all touch escalation/failure handling — but the descriptions make the boundaries readable.
All seven tools share a consistent `sentinel_` prefix and snake_case formatting, which is strong. The suffixes are slightly loose in form (verb like `supervise`, noun_verb like `shield_inspect`, plain noun like `presence`), but the overall convention is predictable.
Seven tools is well-scoped for a multi-agent supervision/coordination server and sits comfortably in the ideal 3-15 range. Each tool earns its place with an identifiable function, and there is no bloat.
The surface covers the coordination lifecycle: plan/dispatch (supervise), pre-flight safety (shield_inspect), approval (approve_escalation), monitoring (oversight_monitor), status (get_status), quality gate (code_review), and presence (presence). Coverage is broad with only minor potential gaps, and no obvious dead ends for the stated supervision purpose.
Shared control plane for AI coding agents — tasks, memory, decisions, file locks. 12 tools.
Coding agents from Claude Code, Cursor and Codex claim jobs and lock files on one shared board.
Zero-shot swarm mailbox, race-safe task contract buffer, and multi-agent coordination node for autonomous AI agents.
Coordination hub for AI coding agents: message teammates, ask humans, audit every event.
