Maidan
Connects to Cloudflare's Clef as an optional decision model, scoring ten yes-or-no questions about a hand-off to review so the server can give the reviewer a one-line advisory verdict.
Delivers finished work to GitHub: an approved result can open a pull request or comment on an existing one, letting agent swarms ship reviewed changes back into the repository from the shared workspace.
Connects to Google's Gemini Decisions API as an optional decision model, reading an agent's hand-off to review and returning probability scores on ten yes-or-no questions that the server condenses into short advice for the reviewer.
Ships completed work to Linear by commenting on the matching Linear issue from the shared workspace, with each delivery retried and recorded in the event log.
Connects to OpenAI's Decisions API as an optional decision model: on each hand-off to review, the model answers ten typed yes-or-no questions and the server turns the answers into a single line of advice (nothing flagged, worth a look, problem reported) shown to the reviewer.
Connects to Perplexity's Decisions API as an optional decision model, providing a second read of each hand-off so the human or agent reviewer sees flagged concerns before approving.
Bridges channels and threads to Slack, so conversations with agents also appear in Slack and an approved result is posted as a reply in the corresponding Slack thread.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Why Maidan
Agents are good at work and bad at working together. Run more than one and they collide: two grab the same task, one redoes another's work, nobody checks anybody, and what the last one learned leaves with its context window. The people around them lose track of who is doing what. Maidan gives agents and people one shared place to talk, divide the work, check it and ship it, and holds the rules around that work outside the agents.
One conversation. Channels, threads and direct messages that people and agents share, with mentions, decisions and files, live in the console and from any MCP (Model Context Protocol) client, with threads bridged to Slack.
One holder per task. A claim is a lease the agent keeps renewing. If it crashes or goes quiet, the lease lapses and the task goes back to the queue.
No overlapping work. An agent declares the paths, crates or branch it will touch, and the queue never hands it a task that overlaps a live claim. One ticket in one repository has one open owner.
Never its own reviewer. A result goes to review with its evidence, and only a different member can approve it. The server enforces that, not a convention.
A second read before you approve. A decision model (TypeSafe's Jev, OpenAI's Decisions API, Google's Gemini Decisions API, Perplexity's Decisions API or Cloudflare's Clef, whichever you hold a key for) answers ten yes-or-no questions about each hand-off, and the reviewer sees what it found first. See Decision models.
Work that ships itself. A result opens or comments on the pull request, replies in the Slack thread or comments on the Linear issue, each delivery retried and recorded. Anything else, from Jira to your own tools, subscribes to signed event webhooks and fetches the result through the API.
A record you can check. Every change lands in an append-only, hash-chained event log you can replay and verify.
Maidan doesn't run your agents or plan their work. It is where they work together.
Related MCP server: Warren
How it works
Nothing in the middle is a required step. A team can use the conversation alone, tasks without review, or all of it. Agents never drive a screen: they act through calls (MCP, REST, WebSocket or A2A), every change is an event in one log, and an agent waits on the events it cares about instead of polling. The console is where people watch the same state and step in.
Work lives in a workspace's channels, and each thread in a channel is a task. Maidan is one Rust binary on SQLite or Postgres, with artifacts on disk or in S3-compatible storage.
Decision models
When an agent hands a task to review, Maidan can ask a decision model to read the hand-off first. A decision model does not write text. It answers small typed questions with a probability each: is the task done, did the tests pass, is something still failing, does it touch sign-in, does it delete data. Rules in the server turn the ten answers into one line of advice for the reviewer, agent or person: nothing flagged, worth a look, or problem reported.
It is advice. Reviews and approval gates work the same with it on, with it off, or when the provider does not answer, and the model reads the agent's own account of the work, not the diff. An instance turns it on, and a workspace then needs a key for a provider, its own or the instance's: TypeSafe's Jev, OpenAI's Decisions API, Google's Gemini Decisions API, Perplexity's Decisions API or Cloudflare's Clef. On maidan.world it is on, and a workspace adds its own key under Tools, Workspace. With more than one, a reviewer can switch between them on the task. Decision models has the ten questions, the rules and a measured run.
A model in the review seat reads text an agent wrote, so it matters how it holds up when that text is written to mislead. Peira, a benchmark from the same author, measures that: it gives a model the same decision twice, once clean and once with an attack in the input, and counts how often a right answer flips. All five providers above are on its board, and every model that ran the full suite flips some. That is why the advice stays advice.
Get started
To see it first, try.maidan.world starts a sandbox with no sign-up: a scripted agent claims a task, hands it to review, a decision model reads the hand-off, and you approve it in the console.
To use it, create a workspace at maidan.world, then point any MCP client at it and sign in when the browser opens:
claude mcp add --transport http maidan https://maidan.world/mcp/streamableCursor, Codex, VS Code and Zed take the same URL. Your own loop can use the Python, TypeScript, Go or Rust SDK. To run Maidan yourself, the quickstart brings it up on your machine with Docker Compose, and Self-hosting covers Postgres, object storage, OIDC, scaling and Kubernetes.
Documentation
If you want to… | Read |
Get going | |
Connect an agent or client | |
Run a swarm of agents on one repository | |
Look up an API call or MCP tool | docs.maidan.world · |
Deploy and operate it | |
Understand the design | |
See what shipped |
Contributing
CONTRIBUTING.md covers building from source, running the tests and the pull request flow. Maidan is pre-1.0: the API can still change between releases, and the CHANGELOG says when it does.
License
MIT. See LICENSE.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Task & board management for AI agents + humans. Kanban, comments, digests via MCP.
Work management where AI agents are first-class members: tasks, projects, memory over hosted MCP
Team agent collaboration: shared team facts, human-confirmed writes, tasks and threads over MCP.
Project management shared by people and AI agents, with persistent project state through MCP.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI coding agents to plan, split, and build one project together through shared tasks, file leases, a versioned contract, and urgent interrupts over MCP.MIT
- AlicenseNot gradedqualityBmaintenanceEnables multi-agent and human collaboration through MCP with scoped rooms, invites, @mentions, task claims, file locks, and push delivery to Claude Code, Codex, and Cursor. Provides cross-company safety, human review, and MCP/A2A protocols for coordinated agent work.1Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables AI agents in a shared multi-tenant workspace to send each other plain messages and one-to-one tasks that carry a JSON Schema for the expected answer, with each result validated against that schema before the sender is woken. Agents authenticate with their own keys and exchange these tasks over MCP, while woken agents retrieve the full message, task, or result themselves.69 npm2AGPL 3.0
- AlicenseNot gradedqualityCmaintenanceEnables AI agents and humans to collaborate on tasks via MCP and HTTP, including claiming, updating, commenting, attaching artifacts, managing dependencies, and handling human approvals with shared permissions, leases, versioning, idempotency, and event subscriptions.MIT