Connect AI Agents to EVC Mesh
MCP server connecting AI agents to EVC Mesh for task management, persistent memory, and multi-agent coordination.
1.0.0Add to Favorites
Why it matters
Integrate your AI agents with the EVC Mesh for seamless multi-agent coordination. This connector facilitates task management, event publishing, and artifact uploads.
Outcomes
What it gets done
Connect AI agents to Mesh via MCP tools
Manage tasks across multiple agents
Publish events and upload artifacts
Share persistent memory and recall across sessions
Install
Add it to your toolbox
Run in your project directory:
curl -fsSL https://spark.entire.vc/get/evc-mesh-mcp | bash Capabilities
Tools your agent gets
Register agent presence and keep the session alive
List all tasks currently assigned to the calling agent
Fetch full task details including comments, artifacts, and metadata
Query tasks in a project by status, priority, label, or assignee
Create a new task with title, description, labels, assignee, and due date
Create a child task under a parent task with optional dependency edge
Transition task status between todo, in_progress, review, and done
Patch task fields such as priority, labels, due date, and title
Overview
EVC Mesh MCP
The MCP server for EVC Mesh, connecting AI agents (Claude Code, Cursor, Cline, OpenClaw) to task management, persistent memory, and multi-agent coordination via a defined Agent Context Protocol and two configurable tool profiles. Use when an AI agent needs to pick up tasks, store durable memory, or coordinate with other agents/humans on EVC Mesh; requires a running Mesh instance and registered agent API key.
What it does
This is the Model Context Protocol server for EVC Mesh, a task management platform for coordinating humans and AI agents, connecting agents like Claude Code, Cursor, Cline, and OpenClaw to Mesh via MCP tools for task management, persistent memory, event publishing, and multi-agent coordination. It ships two tool profiles to manage context window cost: a core profile with 20 essential tools at roughly 6K tokens (3% of a 200K context), suited to Claude Code, Cursor, and other small-context clients, and a full profile with all 45 tools at roughly 14K tokens (7% of 200K), suited to power users and automation/admin agents - selected via the MESH_MCP_PROFILE environment variable, defaulting to full.
It defines an Agent Context Protocol (ACP) that every agent session should follow: at session start, send a heartbeat as online, load accumulated project decisions and conventions via get_project_knowledge, load governance constraints via get_my_rules, pull recent activity via get_context, and check assigned work via get_my_tasks; at session end, publish a persisted summary event and report session metrics via session_report. The core profile's 20 tools cover ACP/identity, task management, communication, memory, and utility. The full profile adds 25 more spanning subtasks and dependencies, atomic task locking for multi-agent coordination, comments and artifact uploads, an event bus, sub-agent registration and team directory lookup, governance/config import-export, and recurring task scheduling.
When to use - and when NOT to
Use this connector when an AI agent needs to participate in EVC Mesh's task-coordination workflow - picking up tasks, reporting progress, storing durable memory, or coordinating with other agents and humans on shared work - across Claude Code, Cursor, Cline, OpenClaw, or any other MCP-compatible client. Use SSE transport mode specifically when multiple agents need to connect through one shared MCP endpoint, serving both the full-profile and core-profile paths simultaneously, authenticated per-connection via bearer token, header, or query parameter.
It requires a running EVC Mesh instance and an agent already registered in Mesh with an API key (agk_...) - it is a thin proxy translating MCP tool calls into REST calls against the Mesh API, with no direct database access, so it's only useful alongside an actual Mesh deployment, not standalone.
Inputs and outputs
Input is MCP tool calls from a connected agent - task queries and updates, memory recall/remember operations, event publishing, or coordination calls like task locking. Output is the corresponding EVC Mesh API response (task data, memory search results, event confirmations), with the server acting purely as a stateless translation layer between MCP and Mesh's REST API.
go install github.com/entire-vc/evc-mesh-mcp@latest
Capabilities
- ACP session lifecycle: heartbeat, load project knowledge/rules/context, check tasks
- Full task management: list/create/update/move/assign tasks, subtasks, dependencies, atomic locking
- Comments, artifact upload/download
- Memory: recall, remember (upsert), forget
- Event bus: publish events/summaries, webhook subscriptions, long-poll for assignments
- Sub-agent registration, team directory, agent profile management
- Governance rules, workspace config import/export
- Recurring task scheduling and triggering
How to install
Install via go install github.com/entire-vc/evc-mesh-mcp@latest or build from source (git clone + go build), requiring Go 1.22+. Configure MESH_API_URL and MESH_AGENT_KEY as required variables, with optional MESH_MCP_PROFILE (core/full), MESH_MCP_TRANSPORT (stdio/sse), and SSE host/port settings - added to Claude Code's .mcp.json or Cursor's MCP settings, or run standalone in SSE mode for shared multi-agent access. Production deploys follow a strict manual order: run database migrations (goose up) first, only then swap the binary, then restart and smoke-test - never swap the binary before migrations succeed, since the MCP server relies on the Mesh API's schema and runs no migrations of its own.
Who it's for
Teams running multi-agent workflows on EVC Mesh who need their AI agents (Claude Code, Cursor, Cline, OpenClaw) to manage tasks, persist memory, and coordinate with each other and human teammates through a standard MCP interface.
Source README
EVC Mesh MCP Server
Model Context Protocol (MCP) server for EVC Mesh - a task management platform for coordinating humans and AI agents.
Connects AI agents (Claude Code, Cursor, Cline, OpenClaw, etc.) to EVC Mesh via MCP tools for task management, persistent memory, event publishing, and multi-agent coordination.
Prerequisites
- Go 1.22+
- Running EVC Mesh instance
- Agent registered in Mesh with an API key (
agk_...)
Installation
go install github.com/entire-vc/evc-mesh-mcp@latest
Or build from source:
git clone https://github.com/entire-vc/evc-mesh-mcp.git
cd evc-mesh-mcp
go build -o evc-mesh-mcp .
Tool Profiles
The MCP server supports two profiles to optimize context window usage:
| Profile | Tools | Context overhead | Best for |
|---|---|---|---|
| core | 20 | ~6K tokens (3% of 200K) | Claude Code, Cursor, small-context models |
| full | 45 | ~14K tokens (7% of 200K) | Power users, automation agents, admin ops |
Set via MESH_MCP_PROFILE environment variable. Default: full.
Configuration
| Variable | Required | Default | Description |
|---|---|---|---|
MESH_API_URL |
Yes | http://localhost:8005 |
Base URL of the Mesh API |
MESH_AGENT_KEY |
Yes (stdio) | - | Agent API key (agk_...) |
MESH_MCP_PROFILE |
No | full |
Tool profile: core or full |
MESH_MCP_TRANSPORT |
No | stdio |
Transport mode: stdio or sse |
MESH_MCP_HOST |
No | 0.0.0.0 |
SSE server bind host |
MESH_MCP_PORT |
No | 8081 |
SSE server bind port |
Claude Code (stdio mode)
Add to your project's .mcp.json:
{
"mcpServers": {
"evc-mesh": {
"command": "evc-mesh-mcp",
"env": {
"MESH_API_URL": "https://your-mesh-instance.example.com",
"MESH_AGENT_KEY": "agk_your-workspace_your-key",
"MESH_MCP_PROFILE": "core"
}
}
}
}
Cursor
Add to Cursor MCP settings (Settings → MCP Servers):
{
"evc-mesh": {
"command": "evc-mesh-mcp",
"env": {
"MESH_API_URL": "https://your-mesh-instance.example.com",
"MESH_AGENT_KEY": "agk_your-workspace_your-key",
"MESH_MCP_PROFILE": "core"
}
}
}
SSE Mode (multi-agent, shared server)
For connecting multiple agents through a shared MCP endpoint:
MESH_API_URL=https://your-mesh-instance.example.com \
MESH_MCP_PORT=8081 \
evc-mesh-mcp --transport sse
SSE mode serves two profiles simultaneously on different paths:
| Path | Profile | Description |
|---|---|---|
/sse + /message |
full | All 45 tools (backward compatible) |
/core/sse + /core/message |
core | 20 essential tools |
Authentication per connection via:
Authorization: Bearer agk_...headerX-Agent-Key: agk_...header?agent_key=agk_...query parameter
Agent Context Protocol (ACP)
At session start, follow these 5 steps in order:
1. heartbeat(status="online") → register as alive
2. get_project_knowledge(project_id) → load accumulated decisions & conventions
3. get_my_rules(project_id) → understand constraints
4. get_context(project_id) → see recent activity + project knowledge
5. get_my_tasks() → check assigned work
At session end:
publish_event(type="summary", memory={persist: true}) → broadcast + persist
session_report(model, tokens_in, tokens_out) → report metrics
MCP Tools - Core Profile (20)
ACP & Identity
| Tool | Description |
|---|---|
heartbeat |
Send heartbeat. Call at session start with status=online |
get_project_knowledge |
Get ALL permanent knowledge (decisions, conventions). ACP Step 2 |
get_my_rules |
Get ALL governance rules (workflow + assignment). ACP Step 3 |
get_context |
Get recent activity + project knowledge. ACP Step 4 |
get_my_tasks |
Get assigned tasks. ACP Step 5 |
Task Management
| Tool | Description |
|---|---|
list_projects |
List workspace projects |
list_tasks |
List tasks with filters (status, priority, assignee, search) |
get_task |
Get task details with optional comments/artifacts/deps |
create_task |
Create a new task |
update_task |
Update task fields |
move_task |
Change task status using slugs |
assign_task |
Assign/unassign a task |
get_task_context |
Get everything about a task in one call |
Communication
| Tool | Description |
|---|---|
add_comment |
Add comment to a task (markdown) |
publish_event |
Publish event + optional memory hint for persistence |
Memory
| Tool | Description |
|---|---|
recall |
Search memory by keywords |
remember |
Save knowledge (UPSERT by key) |
forget |
Delete a memory entry |
Utility
| Tool | Description |
|---|---|
report_error |
Report an error on a task |
session_report |
Report session metrics (model, tokens, cost) |
MCP Tools - Full Profile (adds 25 more)
Additional Task Tools
| Tool | Description |
|---|---|
get_project |
Get project details with statuses and custom fields |
create_subtask |
Create subtask under a parent |
add_dependency |
Add dependency between tasks |
checkout_task |
Atomic task lock for multi-agent coordination |
release_task |
Release atomic task lock |
Comments & Artifacts
| Tool | Description |
|---|---|
list_comments |
List task comments |
upload_artifact |
Upload file/code/log to a task |
list_artifacts |
List task artifacts |
get_artifact |
Get artifact details and download URL |
Event Bus
| Tool | Description |
|---|---|
publish_summary |
Publish work summary (convenience wrapper) |
subscribe_events |
Configure webhook delivery for events |
poll_tasks |
Long-poll for new task assignments |
Agent & Team
| Tool | Description |
|---|---|
register_sub_agent |
Register a sub-agent |
list_sub_agents |
List sub-agents (optionally recursive) |
get_team_directory |
Get workspace team directory |
update_agent_profile |
Update agent role, capabilities, profile |
Governance & Config
| Tool | Description |
|---|---|
get_project_rules |
Get all project rules |
get_assignment_rules |
Get assignment rules |
get_workflow_rules |
Get workflow rules with caller permissions |
import_workspace_config |
Import workspace config from YAML |
export_workspace_config |
Export workspace config as YAML |
Recurring Tasks
| Tool | Description |
|---|---|
create_recurring_task |
Create recurring task schedule |
list_recurring_schedules |
List recurring schedules |
get_recurring_history |
Get instance history for a schedule |
trigger_recurring_now |
Trigger next instance immediately |
Architecture
AI Agent (Claude Code / Cursor / Cline / OpenClaw)
↕ MCP (stdio or SSE)
EVC Mesh MCP Server (core or full profile)
↕ REST API (HTTP)
EVC Mesh API Server
↕
PostgreSQL / Redis / NATS / S3
The MCP server is a lightweight proxy - it translates MCP tool calls into REST API requests. No direct database access needed.
Deploy checklist (prod server - no CI)
evc-mesh-mcp has no CD pipeline; deploys are manual. Mandatory order (per
CLAUDE-workflow.md §1b Deploy Discipline):migrate (goose up) → binary swap → restart. Never swap the binary before migrations pass.
# 1. Build for the prod target
GOOS=linux GOARCH=amd64 go build -o evc-mesh-mcp .
# 2. Copy binary to prod
scp evc-mesh-mcp root@prod-host:/opt/evc-mesh-mcp/evc-mesh-mcp.new
# 3. On the prod host: run migrations FIRST, then swap binary
ssh root@prod-host
# STEP 1 - Run evc-mesh DB migrations (mcp server reads the same DB).
# goose CLI is not installed on the host - use the official docker image.
# If this exits non-zero, STOP - do NOT swap the binary.
DB_URL=$(grep ^DATABASE_URL /opt/evc-mesh/.env.prod | cut -d= -f2-)
docker run --rm --network host \
-v /opt/evc-mesh/migrations:/migrations \
ghcr.io/pressly/goose:latest \
goose -dir /migrations postgres "$DB_URL" up
# STEP 2 - Swap binary (only after migrations succeed)
mv /opt/evc-mesh-mcp/evc-mesh-mcp /opt/evc-mesh-mcp/evc-mesh-mcp.bak.$(date +%Y%m%d-%H%M%S)
mv /opt/evc-mesh-mcp/evc-mesh-mcp.new /opt/evc-mesh-mcp/evc-mesh-mcp
# STEP 3 - Restart
sudo systemctl restart evc-mesh-mcp
# STEP 4 - Smoke test
curl -sf http://localhost:8081/health || echo "SMOKE FAILED"
evc-mesh-mcp does not run its own migrations - it relies on the evc-mesh API's
schema. The goose step above ensures the schema matches before the new binary serves traffic.
Related
- evc-mesh - Core platform (API + Web UI)
- evc-mesh-openclaw-skill - OpenClaw skill (bash scripts)
FAQ
Common questions
Trust
How it checks out
Discussion
Questions & comments · 0
Sign In Sign in to leave a comment.