Skip to content
/

MCP Agent Mail

mcp-agent-mail · Dicklesworthstone/mcp_agent_mail · ★ 2.0k · last commit 2026-05-25

Provides an asynchronous mail-like coordination bus (identities, inboxes, file leases, Git-auditable messages) so multiple coding agents can work the same codebase in parallel without stepping on each other.

Best whenCoordination should be peer-to-peer and voluntary — no central orchestrator needed; file reservation leases and message acknowledgements are sufficient to pr…
Skip ifDeleting files without express permission, Using pip instead of uv
vs seeds
claude-flow's centralized hive-mind or taskmaster-ai's single-agent task decomposition, MCP Agent Mail is coordinator-free: agents …
Primitive shape 47 total
Skills 1 Hooks 3 MCP tools 43
00

Summary

MCP Agent Mail — Summary

MCP Agent Mail is an asynchronous coordination layer for multi-agent coding workflows, exposed as an HTTP-only FastMCP server built in Python 3.14. It gives agents memorable identities (e.g., "GreenCastle"), inbox/outbox messaging with GitHub-Flavored Markdown support, searchable message history, and advisory file-reservation "leases" to prevent agents from stepping on each other's edits. The entire artifact store is Git-backed for human-auditable history, with SQLite as the index and query engine. The project is authored by Jeffrey Emmanuel (Dicklesworthstone) — the same author as the Beads task-tracker ecosystem (cross-batch link to Phase B Batch 11/25), and the install script auto-installs both MCP Agent Mail and the Beads Rust CLI (br) in one pass. It ships 43 MCP tools and ~50 MCP resources over HTTP, a mcp-agent-mail CLI, and Claude Code hooks that auto-check reservations on Edit events and poll the inbox after Bash runs. Unlike seed frameworks that orchestrate agents from a single master controller, MCP Agent Mail is a passive coordination bus: agents register themselves, send mail to each other, and declare file intentions — the server imposes no execution order. Closest seed analog is ccmemory (external MCP coordination layer), but MCP Agent Mail adds inter-agent messaging, file lease conflict detection, and a full Git-backed audit archive that ccmemory lacks.

01

Overview

MCP Agent Mail — Overview

Origin

Created by Jeffrey Emmanuel (Dicklesworthstone), author of the Beads task-tracker ecosystem. The project grew directly from his parallel work building the commercial "Companion" stack for multi-agent Claude Code/Codex automation. The core idea — email for coding agents — was captured in docs/planning/project_idea_and_guide.md before any code was written; the README encourages reading that document as the design bible.

Philosophy

"It's like gmail for your coding agents!"

The fundamental position is that parallel agent coordination fails because agents share no communication fabric. MCP Agent Mail provides the minimal primitive set needed for multiple agents to coexist in one codebase without babysitting: identity, messaging, and file-lock signaling. No orchestration engine. No forced execution order. The server is deliberately passive — it doesn't direct agents, it enables them to coordinate themselves.

Key principles from the README:

  • "Git-backed mailboxes, advisory file reservations, Typer CLI helpers, and searchable archives keep independent agents aligned without babysitting. Every instruction, lease, and attachment is auditable."
  • "One disciplined hour of GPT-5 Codex—when it isn't waiting on human prompts—often produces 10–20 'human hours' of work."
  • Designed to work with any FastMCP client: Claude Code, Codex, Gemini CLI, Factory Droid, etc.

Workflow philosophy

The README's "From Idea Spark to Shipping Swarm" section captures the intended developer loop:

  1. Write a scrappy blurb about the problem (≈15 min)
  2. Feed to GPT-5 Pro to get a granular Markdown plan
  3. Clone a tuned AGENTS.md, let Codex scaffold + populate Beads tasks
  4. Register each agent identity in Agent Mail
  5. Let agents acknowledge AGENTS.md + Beads backlog before touching code
  6. Use Message Stacks (commercial Companion app) or manual prompts to feed panes

This project is tightly coupled to the Beads ecosystem. The installer replaces the Go-based bd CLI with the Rust reimplementation br, and the Beads Viewer TUI (bv) is also installed. This links to Phase B Batch 11/25 analysis of the Beads task tracker.

02

Architecture

MCP Agent Mail — Architecture

Distribution

  • Type: standalone-repo (Python package, installable via uv or pip)
  • Version: 0.3.2 (pyproject.toml)
  • Language: Python 3.14 only (explicit no-compatibility stance)

Install Methods

# One-line installer (recommended)
curl -fsSL "https://raw.githubusercontent.com/Dicklesworthstone/mcp_agent_mail/main/scripts/install.sh?$(date +%s)" | bash -s -- --yes

# Manual install
git clone https://github.com/Dicklesworthstone/mcp_agent_mail
uv python install 3.14
uv venv -p 3.14 && source .venv/bin/activate
uv sync
scripts/automatically_detect_all_installed_coding_agents_and_install_mcp_agent_mail_in_all.sh

After installation, the am shell alias starts the server.

Required Runtime

  • Python 3.14+
  • uv (package manager)
  • Git (for auditable artifact storage)
  • SQLite (bundled via aiosqlite)
  • Optional: Redis (for rate-limiting)

Directory Structure

mcp_agent_mail/
├── src/mcp_agent_mail/
│   ├── app.py          # FastMCP server — all 43 tools + ~50 resources defined here
│   ├── cli.py          # Typer CLI for server management and admin commands
│   ├── db.py           # SQLAlchemy async engine + session management
│   ├── models.py       # SQLModel ORM models
│   ├── config.py       # python-decouple settings from .env
│   ├── guard.py        # pre-commit hook install/uninstall
│   ├── storage.py      # Git-backed archive operations
│   ├── llm.py          # LLM completion (for summarize tools)
│   └── templates/      # Jinja2 message templates
├── .claude/
│   ├── settings.json   # Claude Code hooks (SessionStart, PreToolUse/Edit, PostToolUse/Bash)
│   └── settings.json.template
├── scripts/
│   ├── install.sh
│   ├── run_server_with_token.sh
│   └── automatically_detect_all_installed_coding_agents_and_install_mcp_agent_mail_in_all.sh
├── .mcp.json           # Claude Code MCP config (HTTP transport, port 8765)
├── cursor.mcp.json     # Cursor-specific MCP config
├── codex.mcp.json      # Codex-specific MCP config
├── gemini.mcp.json     # Gemini CLI-specific MCP config
├── windsurf.mcp.json   # Windsurf-specific MCP config
└── pyproject.toml      # Dependencies (fastmcp, SQLAlchemy, GitPython, litellm, ...)

Config Files

  • .env — all secrets (bearer token, server port, optional Redis URL)
  • ~/.zshrc / ~/.bashrcam alias added by installer

MCP Transport

HTTP-only (type: http) on port 8765 with Bearer token authentication:

{
  "mcpServers": {
    "mcp-agent-mail": {
      "type": "http",
      "url": "http://127.0.0.1:8765/api/",
      "headers": { "Authorization": "Bearer YOUR_BEARER_TOKEN" }
    }
  }
}

Target AI Tools

Claude Code, Codex, Gemini CLI, Cursor, Windsurf, Factory Droid — any FastMCP HTTP client.

Key Dependencies

fastmcp, uvicorn, fastapi, SQLAlchemy (async), GitPython, litellm (for LLM summarization), rich, typer, filelock, psutil

03

Components

MCP Agent Mail — Components

MCP Tools (43 tools)

Identity & Registration

Tool Purpose
health_check Returns server readiness information
ensure_project Create or retrieve a project by human key
register_agent Register an agent identity within a project
whois Look up agent information by name
create_agent_identity Create a new agent identity
list_window_identities List all active window identities
rename_window Rename a session window
expire_window Expire a window identity

Messaging

Tool Purpose
send_message Send a GitHub-Flavored Markdown message to an agent
reply_message Reply to an existing message thread
request_contact Request to establish contact with another agent
respond_contact Accept/decline a contact request
list_contacts List all established contacts
set_contact_policy Configure auto-accept/deny policies
fetch_inbox Fetch inbox messages for an agent
fetch_topic Fetch messages by topic/thread
mark_message_read Mark a message as read
acknowledge_message Acknowledge a message (confirm receipt/action)

Macros (bundled multi-tool flows)

Tool Purpose
macro_start_session Register identity + fetch pending inbox in one call
macro_prepare_thread Prepare a coordinated thread between agents
macro_file_reservation_cycle Acquire reservations + run work + release in one call
macro_contact_handshake Full cross-agent contact establishment flow

Search & Summarization

Tool Purpose
search_messages Full-text search across message history
summarize_thread LLM-powered thread summarization
summarize_recent Summarize recent activity
fetch_summary Retrieve a cached summary

File Reservations (Leases)

Tool Purpose
file_reservation_paths Acquire advisory leases on file globs
release_file_reservations Release held reservations
force_release_file_reservation Force-release another agent's reservation
renew_file_reservations Extend TTL on existing reservations

Build Slots

Tool Purpose
acquire_build_slot Reserve a build slot (prevents concurrent builds)
renew_build_slot Extend a build slot TTL
release_build_slot Release a build slot

Pre-commit Guard

Tool Purpose
install_precommit_guard Install git pre-commit hook that blocks conflicting commits
uninstall_precommit_guard Remove pre-commit hook

Product-scoped (cluster: "products" feature)

Tool Purpose
ensure_product Create or retrieve a product (cross-project grouping)
products_link Link projects to a product
search_messages_product Search messages across all projects in a product
fetch_inbox_product Fetch inbox across product projects
summarize_thread_product Summarize threads at product scope

MCP Resources (~50 resources)

Resources provide read-only fast access via URI:

Pattern Purpose
resource://inbox/{agent} Agent inbox
resource://thread/{thread_id} Full thread with bodies
resource://mailbox/{agent} Full mailbox view
resource://outbox/{agent} Sent messages
resource://message/{id} Single message
resource://agents/{project_key} Agent directory
resource://file_reservations/{slug} Active reservations
resource://views/urgent-unread/{agent} Urgent unread filter
resource://views/ack-required/{agent} Acknowledgement-required messages
resource://config/environment Server environment info
resource://tooling/directory Tool catalog
resource://tooling/schemas Tool schemas
resource://tooling/metrics Tool usage metrics
resource://tooling/locks Active file locks
resource://project/{slug} Project details

CLI (mcp-agent-mail / am alias)

Typer-based CLI providing server management and admin operations:

  • config set-port <port> — change HTTP port
  • file_reservations active <path> — show active reservations
  • acks pending <path> <agent> — show pending acknowledgements
  • mail status <path> — show agent mail status
  • guard status <path> — show pre-commit guard status

Claude Code Hooks (3 hooks in .claude/settings.json)

Event Matcher Purpose
SessionStart (none) Show active file reservations + pending acks for the current agent
PreToolUse Edit Check for expiring reservations on files about to be edited
PostToolUse Bash Poll inbox every 120 seconds after Bash tool runs

SKILL.md

A SKILL.md file is provided for auto-discovery by Claude Code skill-loading systems, including the Beads companion ecosystem.

Scripts

  • scripts/install.sh — one-line installer (detects OS, installs uv, configures all agent tools)
  • scripts/automatically_detect_all_installed_coding_agents_and_install_mcp_agent_mail_in_all.sh — auto-configure for all detected agent tools
  • scripts/run_server_with_token.sh — restart server with saved token
05

Prompts

MCP Agent Mail — Prompts

AGENTS.md (Core Agent Instructions)

The AGENTS.md file ships hardcoded operational rules for any agent using this repo — an unusually strong example of iron-law prompt engineering:

RULE NUMBER 1 (NEVER EVER EVER FORGET THIS RULE!!!): YOU ARE NEVER ALLOWED TO DELETE A FILE 
WITHOUT EXPRESS PERMISSION FROM ME OR A DIRECT COMMAND FROM ME. EVEN A NEW FILE THAT YOU 
YOURSELF CREATED, SUCH AS A TEST CODE FILE. YOU HAVE A HORRIBLE TRACK RECORD OF DELETING 
CRITICALLY IMPORTANT FILES OR OTHERWISE THROWING AWAY TONS OF EXPENSIVE WORK THAT I THEN 
NEED TO PAY TO REPRODUCE. AS A RESULT, YOU HAVE PERMANENTLY LOST ANY AND ALL RIGHTS TO 
DETERMINE THAT A FILE OR FOLDER SHOULD BE DELETED. YOU MUST **ALWAYS** ASK AND *RECEIVE* 
CLEAR, WRITTEN PERMISSION FROM ME BEFORE EVER EVEN THINKING OF DELETING A FILE OR FOLDER 
OF ANY KIND!!!

Prompting technique: Uppercase emphasis + emotional framing + permanent capability revocation. This is an extreme example of the "Iron Law" pattern — but personalized with epistemic history ("you have a horrible track record").


AGENTS.md — Coordination Usage Section

## MCP Agent Mail — coordination for multi-agent workflows

What it is
- A mail-like layer that lets coding agents coordinate asynchronously via MCP tools and resources.
- Provides identities, inbox/outbox, searchable threads, and advisory file reservations.

How to use effectively
1) Same repository
   - Register an identity: call `ensure_project`, then `register_agent` using this repo's 
     absolute path as `project_key`.
   - Reserve files before you edit: `file_reservation_paths(project_key, agent_name, ["src/**"], 
     ttl_seconds=3600, exclusive=true)` to signal intent and avoid conflict.
   - Communicate with threads: use `send_message(..., thread_id="FEAT-123")`.
   
Macros vs granular tools
- Prefer macros when you want speed or are on a smaller model: `macro_start_session`, 
  `macro_prepare_thread`, `macro_file_reservation_cycle`, `macro_contact_handshake`.
- Use granular tools when you need control: `register_agent`, `file_reservation_paths`, 
  `send_message`, `fetch_inbox`, `acknowledge_message`.

Prompting technique: Procedural instruction list with explicit tool names and signatures. The "macros vs granular" distinction is a classic progressive disclosure pattern — small model path vs large model path.


SessionStart Hook Command (agent-side injection)

{
  "type": "command",
  "command": "cd '/home/ubuntu/mcp_agent_mail' && uv run python -m mcp_agent_mail.cli file_reservations active '/home/ubuntu/mcp_agent_mail'"
}

Technique: Ambient context injection — agent gets the active reservation list before it sees the user's message, so it can reason about conflicts without asking.


PreToolUse/Edit Hook Command

{
  "type": "command",
  "command": "cd '/home/ubuntu/mcp_agent_mail' && uv run python -m mcp_agent_mail.cli file_reservations soon '/home/ubuntu/mcp_agent_mail' --minutes 10"
}

Technique: Pre-action guard — checks for leases expiring within 10 minutes before any Edit tool use, giving the agent an opportunity to renew or proceed carefully.

09

Uniqueness

MCP Agent Mail — Uniqueness

differs_from_seeds

The closest seed analog is ccmemory — both provide an external MCP server that extends agent memory beyond the conversation window. However, ccmemory stores graph-structured semantic memory (Neo4j) for a single agent's knowledge retrieval, while MCP Agent Mail provides inter-agent communication primitives: identities, inboxes, message threading, and file reservation leases for multiple simultaneous agents. MCP Agent Mail has no semantic retrieval; it has transactional coordination. The architecture is closer to a message broker (like RabbitMQ or Kafka) than a memory store, but scaled down to two-agent+ coordination via a FastMCP HTTP server. Neither taskmaster-ai (single-agent task decomposition) nor claude-flow (hive-mind centralized orchestration) match this pattern — they both have an explicit coordinator. MCP Agent Mail is coordinator-free peer-to-peer.

Distinctive Positioning

  1. Author pedigree: Same author as Beads task tracker — the install script bundles both, creating a complete "task tracking + agent communication" stack from one source.
  2. Git-backed audit trail: Every message, reservation, and agent action is written to a Git-backed archive. This is the only framework in the corpus that provides human-readable, versionable communication history.
  3. File lease model: The advisory file reservation system is novel — no other seed framework provides explicit intent signaling at the file level for concurrent agent coordination.
  4. Macro tools: The bundling of multi-step coordination flows into single MCP tool calls (e.g., macro_file_reservation_cycle) is a form of prompt compression that reduces round-trips on smaller models.
  5. Cross-tool support: 5 different .mcp.json files — the widest tool coverage in this batch.

Observable Failure Modes

  • Stale leases: If an agent crashes without releasing reservations, the TTL auto-expires them — but long TTLs can block other agents for hours
  • Git lock contention: Heavy concurrent write traffic can trigger GitIndexLockError (the code has explicit handling for this)
  • No enforcement: File reservations are advisory only — an agent can still edit a file despite another agent's exclusive lease; the conflict is only detected at commit time
  • Complexity cliff: 43 tools + 50 resources makes tool-discovery expensive for smaller models; the macro_* tools partially mitigate this
  • Single-machine assumption: The HTTP server is always localhost-only (127.0.0.1) — no distributed multi-machine support
04

Workflow

MCP Agent Mail — Workflow

Phases

MCP Agent Mail does not impose an execution workflow — it is a coordination fabric. The following describes the recommended agent workflow when using it:

Phase Artifact Description
1. Server Start Running HTTP server on port 8765 am alias starts the FastMCP server
2. Project Registration Project record in SQLite + Git archive Agent calls ensure_project with repo path
3. Identity Registration Agent record in DB Agent calls register_agent with a memorable name (e.g., "GreenCastle")
4. Session Start Macro Inbox snapshot + reservation snapshot macro_start_session bundles registration + inbox fetch
5. File Reservation .beads-style lease records in DB Agent calls file_reservation_paths before editing files
6. Coordinated Work Code changes, messages to other agents Agent works, sends status messages, checks for conflicts
7. Inbox Poll Unread messages PostToolUse/Bash hook checks inbox every 120s
8. Acknowledgement Ack records in DB Agent calls acknowledge_message on action-required messages
9. Reservation Release Lease expiry in DB Agent calls release_file_reservations or lets TTL expire
10. Commit Guard Pre-commit hook blocks conflicting pushes install_precommit_guard adds git hook that checks active exclusive leases

Approval Gates

The server has no automated approval gates — it is a passive coordination layer. The pre-commit guard is the only "hard stop": it blocks commits when another agent holds an exclusive file reservation that conflicts with the files being committed.

Multi-Repo Coordination

Two patterns:

  • Single project bus: All repos use same project_key; reservations partitioned by glob patterns (e.g., frontend/** vs backend/**)
  • Separate projects: Each repo has its own project_key; agents use macro_contact_handshake to link across projects, then share a thread_id for audit

Macro vs Granular

  • Prefer macros (macro_start_session, macro_prepare_thread, macro_file_reservation_cycle, macro_contact_handshake) for speed
  • Use granular tools (register_agent, file_reservation_paths, send_message, etc.) when fine-grained control is needed
06

Memory Context

MCP Agent Mail — Memory & Context

State Storage

SQLite (Primary Index)

  • Engine: SQLAlchemy async with aiosqlite
  • Tables: Agent, AgentLink, FileReservation, Message, MessageRecipient, MessageSummary, Project, ProjectSiblingSuggestion, Product, ProductProjectLink, WindowIdentity
  • Location: project-specific data directory (configured via .env)
  • Access pattern: All queries are async; uses atomicWrite() for corruption safety

Git Archive (Audit Store)

  • Every message bundle, agent profile, file reservation record is written to a Git-backed archive via GitPython
  • Human-auditable: git log shows the full history of agent communications
  • Import/export: the archive is designed to be checkable into the project repo

In-Memory Caches

  • Recent tool calls cached per-session for metrics
  • Capability mappings loaded at startup from a capabilities mapping file
  • _recent_tool_calls deque for activity tracking

Persistence

  • Scope: Per-project (the project_key determines the storage namespace)
  • Cross-session: Yes — messages, reservations, and agent identities persist across server restarts via SQLite
  • TTL: File reservations have configurable ttl_seconds; auto-expire when TTL passes

Handoffs Between Agents

The entire design is a handoff protocol:

  1. Agent A sends a message with thread_id="FEAT-123" to Agent B
  2. Agent B calls fetch_inbox or reads resource://inbox/AgentB
  3. Agent B calls acknowledge_message to confirm receipt
  4. Both agents can call summarize_thread for a compact cross-session recap

Context Compaction

The summarize_recent and summarize_thread tools use litellm (an LLM abstraction layer) to produce compact summaries of long thread histories. This is the explicit compaction mechanism — agents call it when their token budget for thread context is running low.

File Reservation as Memory

File leases are persisted in SQLite and function as shared working memory: any agent can query which files are locked, by whom, with what TTL. The resource://file_reservations/{slug} endpoint provides a live view.

State Files Written by Framework

  • SQLite database: $AGENT_MAIL_DATA_DIR/agent_mail.db
  • Git archive: $AGENT_MAIL_STORAGE_ROOT/<project-slug>/ (Git repo)
  • Lock signals: $AGENT_MAIL_DATA_DIR/notifications/
  • Per-window identity files: written during write_agent_profile()
07

Orchestration

MCP Agent Mail — Orchestration

Multi-Agent Pattern

Pattern: Peer-to-peer (swarm-adjacent) coordination. No central orchestrator. Agents discover each other via the directory, communicate via messages, and coordinate via file reservations. The server is purely reactive — it responds to tool calls; it never directs agent behavior.

Max concurrent agents: Unlimited (bounded only by SQLite write concurrency and Git lock behavior)

Isolation Mechanism

  • File reservations: Advisory-only (not OS-level locks). An agent can check for conflicts before editing, but the server does not block filesystem operations.
  • Build slots: Mutually-exclusive DB records preventing concurrent builds
  • Pre-commit guard: Hard stop at git commit time if another agent holds an exclusive lease on files in the commit

No process-level or container-level isolation — agents run in their own terminals/processes and coordinate voluntarily via the server.

Execution Mode

Event-driven — the server is always running (HTTP daemon on port 8765). Agents connect as needed. The Claude Code hooks make it partially event-driven: inbox is checked automatically after Bash tool use, and reservations are checked before Edit.

Multi-Model

Not applicable at the server level — MCP Agent Mail is model-agnostic. The LLM used for summarization is configured via litellm environment variables and is a separate concern from the coordination layer.

Consensus Mechanism

Advisory leases + pre-commit guard. Not a formal consensus protocol (no raft/quorum). Conflict detection is best-effort: if two agents both want the same file, the first to call file_reservation_paths(exclusive=true) wins the DB record; the second gets a warning in the response; the pre-commit guard blocks commits from the second agent.

Prompt Chaining

The macro tools implement prompt-chaining within a single MCP tool call: macro_file_reservation_cycle bundles (acquire leases → do work → release leases) into one agent invocation, reducing the number of round-trips.

Crash Recovery

  • Server restarts pick up all existing SQLite state automatically
  • Git archive is durable across restarts
  • TTL-based auto-expiry of reservations prevents dead agent leases from blocking work permanently

Cross-Session Handoff

Full cross-session continuity: message history, reservation history, and agent identities all persist in SQLite. A new agent process can call macro_start_session and immediately see the context of previous sessions.

08

Ui Cli Surface

MCP Agent Mail — UI & CLI Surface

CLI Binary: mcp-agent-mail

The project ships a Typer-based CLI registered as mcp-agent-mail in pyproject.toml scripts:

  • mcp-agent-mail config set-port <port> — change server port
  • mcp-agent-mail file_reservations active <path> — list active file reservations
  • mcp-agent-mail acks pending <path> <agent> — list pending acknowledgements
  • mcp-agent-mail mail status <path> — agent mail status
  • mcp-agent-mail guard status <path> — pre-commit guard status

Shell alias: The installer adds am to ~/.zshrc or ~/.bashrc as a quick server-start alias (runs scripts/run_server_with_token.sh from the project directory).

Web UI (web/ directory)

The repo contains a web/ directory — contents not fully enumerated, likely a minimal status/monitoring page. The server exposes FastAPI HTTP endpoints alongside the FastMCP interface, suggesting a REST API layer is also accessible.

Dashboard (Beads Viewer bv)

The installer optionally installs bv, the Beads Viewer TUI, which provides an interactive terminal dashboard for Beads task tracking. This is a separate tool in the Beads ecosystem rather than MCP Agent Mail itself.

IDE / Agent Tool Integration

The installer script auto-detects installed coding agent tools and writes the appropriate .mcp.json configuration:

  • cursor.mcp.json.cursor/mcp.json
  • codex.mcp.json → codex config
  • gemini.mcp.json → Gemini CLI config
  • windsurf.mcp.json → Windsurf config
  • .mcp.json → Claude Code config

All use HTTP transport to http://127.0.0.1:8765/api/ with Bearer token.

Observability

  • Rich console output: The rich_logger.py module provides colorful structured console output for all server operations
  • resource://tooling/metrics: Exposes tool usage counts per tool per agent
  • resource://tooling/locks: Live view of active Git and file locks
  • Claude Code hooks: Inject reservation and inbox state into Claude's context at SessionStart, PreEdit, and PostBash events — giving the agent direct observability without explicit queries

Port

Default: 8765 (configurable via --port flag or mcp-agent-mail config set-port)

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…