> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monolex.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# connector.json vs MCP

> MCP connects AI to tools. connector.json connects AI to AI. They're complementary layers.

# connector.json vs MCP

## Different Layers, Same Ecosystem

```
connector.json:  AI ↔ AI     (orchestration — who does what, when, where)
MCP:             AI → tool   (access — connect to a service, call a function)
```

They solve different problems and work together.

## MCP: Tool Access Protocol

MCP (Model Context Protocol) lets AI connect to external tools and data:

```json theme={null}
{
  "mcpServers": {
    "github": { "command": "npx", "args": ["@anthropic/mcp-github"] },
    "postgres": { "command": "npx", "args": ["@anthropic/mcp-postgres"] }
  }
}
```

* AI calls `github.create_pr()` → MCP sends request → GitHub API → response
* AI calls `postgres.query()` → MCP sends request → database → results

The target is **passive**. Tools don't initiate. They respond.

## connector.json: AI Orchestration Spec

connector.json lets AI coordinate with other AI:

```json theme={null}
{
  "models": { "primary": "claude", "review": "codex" },
  "pipeline": {
    "phases": [
      { "name": "implement", "model": "primary" },
      { "name": "review", "model": "review" }
    ]
  }
}
```

* Claude implements → Codex reviews → results synthesized
* Both are **active participants**. Both reason, decide, act.

The target is **active**. Other AI agents that think and respond intelligently.

## How They Compose

connector.json includes MCP as a tool configuration:

```json theme={null}
{
  "connector": "2.0",
  "models": { "primary": "claude" },
  "tools": {
    "mcp": ["github", "postgres", "chrome-devtools"]
  },
  "pipeline": {
    "phases": [
      {
        "name": "investigate",
        "model": "primary",
        "prompt": "Use GitHub MCP to find recent PRs. Use Postgres MCP to check migration status."
      }
    ]
  }
}
```

MCP servers are available inside connector.json sessions.
The AI worker can use MCP tools while participating in the connector pipeline.

## Comparison Table

|                   | MCP                      | connector.json                  |
| ----------------- | ------------------------ | ------------------------------- |
| What it connects  | AI → tools/data          | AI ↔ AI                         |
| Target            | Passive (responds)       | Active (reasons)                |
| Direction         | One-way request-response | Multi-directional collaboration |
| Protocol          | JSON-RPC over stdio/SSE  | JSON spec → PTY sessions        |
| Session isolation | Not applicable           | worktree, sandbox per session   |
| Cost routing      | Not applicable           | Route by model cost/capability  |
| Failover          | Not applicable           | Switch to different LLM         |
| Multi-phase       | Not applicable           | Pipeline with sequential phases |
| Cross-machine     | Server can be remote     | Workers on different machines   |
| Standard body     | Anthropic-led            | OpenCLIs / Monolex              |

## Layer Diagram

```
┌─────────────────────────────────────────────┐
│  connector.json (orchestration)             │
│  Models, pipeline, session isolation        │
│  ┌─────────────────────────────────────┐    │
│  │  MCP (tool access)                  │    │
│  │  github, postgres, chrome, slack    │    │
│  └─────────────────────────────────────┘    │
│  ┌─────────────────────────────────────┐    │
│  │  PTY-for-AI (execution)             │    │
│  │  daemon, headless, session plugins  │    │
│  └─────────────────────────────────────┘    │
└─────────────────────────────────────────────┘
```

connector.json sits on top. MCP and PTY-for-AI are execution layers inside it.