M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
B

Binex MCP Server

Community
Open-source visual orchestrator for AI agent workflows, 100% local
How to install ↓ Compare GitHub source repository ↗
Category
Dev Tools #308 of 438
Stars
★ 63 Popular
Transport
stdio (local process)
Runtime
Python 3.11+ · Docker
Credentials
Optional API key
License
MIT
Last commit
Tools
3
45FMRS · D

Binex is a local-first, MIT-licensed runtime for AI agent workflows whose MCP server exposes runs, evals, and artifacts to coding agents. It is best suited to developers who want to debug and compare workflows without migrating their existing frameworks, but it requires a local Binex install on Python 3.11+ and offers no hosted cloud option.

Strongest · Documentation 12/20 Weakest · Reliability 6/20

Reliability
6/20
Security and permissions
8/20
Maintenance
9/20
Documentation
12/20
Setup experience
10/20
Why each score
Reliability 6/20
The static review only has the README and repo metadata. No server manifest is cached, and no committed tests, CI workflow contents, or MCP init/tool-list handshake evidence are shown. The README asserts capabilities such as 10 builtin tools, `binex mcp serve` exposing MCP tools, eval/golden gating, and 9 pattern nodes, but no source snippet verifies that declared tools match real behavior, error handling, or dependency control. The CI/E2E/coverage badges are untrusted evidence and no verified execution evidence accompanies them, so calibration caps reliability at 12; the missing manifest plus absent test/error-path evidence lower it further to 6.
Security and permissions 8/20
The README explicitly claims a fully local, zero-telemetry, no-cloud posture with data confined to `.binex/`, which is a restrained and creditable default. However, the static material does not show credential handling (API keys are only mentioned as environment variables, with no isolation or validation logic), does not state confirmation requirements for high-risk capabilities such as `shell_command`, `local://` callables, or `python://` tools, and does not disclose the outbound network scope of MCP stdio/HTTP transports, the A2A gateway, or `BINEX_REGISTRY_URL`. Least privilege, explicit confirmation, and data-flow disclosure are therefore incomplete, and missing evidence is a deduction. No malware, credential theft, exfiltration, fabricated maintainers, or hardcoded real secrets were found, so no red line applies and the score stays out of the 0-4 band.
Maintenance 9/20
The repo is not archived, ships an MIT license, and provides both issues and a docs site, so a basic maintenance framework exists. Yet with only 62 stars, 2 open issues, and no verifiable release cadence, commit history, dependency-update policy, or security-response channel described, governance and versioning evidence is thin. Since popularity is explicitly not a scoring signal, the gaps in ownership and update-path transparency reduce the score to 9.
Documentation 12/20
The README is comparatively layered: install paths, Docker, Web UI walkthrough, a full CLI command table, YAML examples, configuration environment variables, architecture layout, and an examples inventory are all present, which is a usable mid-to-upper position. Deductions: there is no complete copy-paste MCP client configuration, no parameter-level documentation for builtin/mcp/python tools or their limits, no explanation of how cost and budget figures are actually measured, and no troubleshooting section. It also cites specific numbers (112 prompt templates, 32 REST endpoints, 29 examples) that cannot be verified from the supplied material, creating a risk that documentation overstates capability.
Setup experience 10/20
The README gives a short path of `pip install binex` followed by `binex ui`, plus a Docker Compose flow and a one-line `claude mcp add binex -- binex mcp serve` for MCP clients, so the install route is clear and mainstream-client configuration is exemplified. Against that, it requires Python 3.11+, the Web UI needs a frontend build, and the A2A/plugin/scheduler components add complexity. Most importantly, the MCP server parameters, transport, auth, and environment inheritance are not given with verifiable detail, which is a hidden assumption. Under calibration, setup cannot exceed 15 without source-level execution evidence, so with these gaps it scores 10.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or codeUses the networkConnects to a database

Best for

  • Developers already using Binex who want to inspect runs through a coding agent
  • Teams needing a local-first, debuggable agent workflow toolchain

Not for

  • Users wanting a hosted cloud tracing service instead of a local runtime
  • Environments without Python 3.11+ and Binex installed

Required permissions

  • Read and write the local Binex store (default `.binex` directory with a SQLite database and JSON artifact files)
  • Read locally configured LLM provider API keys (needed to run workflows)
  • Communicate with the MCP client process over stdio

Risks and side effects

  • Exposed runs, evals, and artifacts are written to the local `.binex` directory and may contain sensitive prompts or outputs
  • If cloud LLM providers are configured, prompts and data are sent to those providers
  • Any local process able to invoke the MCP server can read run data

Setup

Before you start

Runtime：Python 3.11+ · Docker

OPENAI_API_KEY optionalsecret OpenAI API key used when running LLM workflows (or use Ollama for fully local runs); not required.
Other optional settings (5)
BINEX_STORE_PATH optional Directory for the SQLite database and artifacts, defaults to .binex; not required.
BINEX_DEFAULT_DEADLINE_MS optional Default node timeout in milliseconds, defaults to 120000; not required.
BINEX_DEFAULT_MAX_RETRIES optional Default retry count for failed nodes, defaults to 1; not required.
BINEX_DEFAULT_BACKOFF optional Retry backoff strategy, fixed or exponential, defaults to exponential; not required.
BINEX_REGISTRY_URL optional Default A2A agent registry URL, defaults to http://localhost:8000; not required.
  1. Install: pip install binex (requires Python 3.11+).
  2. Register Binex as an MCP server: claude mcp add binex -- binex mcp serve.
  3. Launch from Claude Code, Cursor, or another MCP-compatible client to use the binex_debug, binex_eval_run, and binex_diff tools.
.mcp.json 
{"mcpServers":{"binex":{"command":"binex","args":["mcp","serve"]}}}

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "binex": {
      "command": "binex",
      "args": [
        "mcp",
        "serve"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add binex -- binex mcp serve

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Install with `pip install binex`, add the server via `claude mcp add binex -- binex mcp serve`, then confirm the tools binex_debug, binex_eval_run and binex_diff appear in the client's tool list; running `binex hello` first proves the CLI itself works without any API keys.

Troubleshooting

  1. Verify the `binex` command is on PATH and Python is 3.11 or newer
  2. Check the MCP client config uses the command and args `binex mcp serve`
  3. Confirm the `.binex` store directory is writable, or check the `BINEX_STORE_PATH` environment variable
  4. Restart the MCP client and check its logs if tools do not appear

Things to try

Once connected, you can ask your AI assistant things like:

  • Debug the latest run and show me per-node inputs and outputs.
  • Compare my last two runs and tell me which nodes diverged.
  • Run the eval suite against the blessed baseline and report any regressions.
  • Show the cost breakdown per node for the most recent workflow run.

Tools 3

binex_debug read-only
Inspect per-node inputs and outputs of a run as a post-mortem.
binex_eval_run writes
Run a YAML eval suite against blessed baselines for regression testing.
binex_diff read-only
Compare two runs side by side with filtering for changes, failures, and cost deltas.

Use cases

Inspect and debug Binex workflow runs from Claude Code or Cursor
Run eval suites against baselines for agent pipelines
Compare two runs to spot node-level divergence and cost changes

Supported clients

Claude Code
CursorPartial support

Listed from the project's documentation, not tested by this site.

Overview

Binex is an open-source, fully local runtime for AI agent workflows, offering DAG pipelines, artifact lineage, and replayable runs. Through binex mcp serve, it exposes runs, evals, and artifacts as MCP tools for Claude Code, Cursor, or any MCP-compatible agent. The project is built with Python, React, FastAPI, and TypeScript, is MIT licensed, and includes no telemetry.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →
Compare with other MCP servers

Source revision 6a9b8e832aa7 Data synced 2026-10-19 Read the FMRS scoring method