Drive Farmero from Claude, ChatGPT, or any agent that speaks MCP — over the same local engine, on your Mac.

Farmero runs a local engine on your Mac and already exposes it to the app and to farmeroctl. The MCP server exposes that same engine to any agent that speaks the Model Context Protocol — so you can ask Claude (or another MCP client) to check the fleet, read your verification rate, or queue a post, without leaving the chat.

It runs entirely on your Mac. There is no cloud in the path and no port opened to the network: the server talks to the engine over the same loopback address and token the app uses, read fresh from the engine's own file each call.

What it can do

Tool	What it answers
`list_phones`	The connected iPhones and their runner state.
`fleet_status`	What each phone is doing right now.
`list_posts`	The post queue and whether anything can go out.
`verification_rate`	Verified-live over Share-tapped — the number no other tool records — with a per-platform split.
`warmup_plans`	The warm-up schedule per phone, and whether the fleet is paused.
`posting_settings`	The post-publish wait and whether publishing is armed.
`list_accounts`	The accounts on the fleet, per phone.
`fleet_why`	Every phone, one verdict each — who is blocked and by what, in one read.
`phone_why`	Why one phone is (not) running — Pause-all, its own flag, its runner and why it is down, a running job, the next smart block, the last run — in the order they block, with one verdict.
`phone_log`	The wiring log for one phone — why one that will not come up.
`phone_screenshot`	A live image of one phone's screen — the agent can see it.
`schedule_post`	Queue a post on one phone and account.
`set_fleet_paused`	Pause or resume warm-ups (not publishing).
`set_account_wait`	Give one account its own post-publish wait.

The read tools are always safe. schedule_post only queues a post — publishing still obeys the one switch on your Posting page, so an agent cannot make something go live that you have not armed yourself.

Point a client at it

The server speaks JSON-RPC over stdio, the standard MCP transport, so a client launches it as a command. In an MCP client's server configuration:

{
  "mcpServers": {
    "farmero": {
      "command": "farmeroctl",
      "args": ["mcp"]
    }
  }
}

Run farmeroctl mcp (it launches the server on stdio), and make sure Farmero — or the daemon — is running, so there is a live engine to talk to. The server reads the engine's token itself; you never paste one.

The engine, farmeroctl, and this MCP server are three doors into the same local daemon. Nothing here is a second copy of your fleet's state — it is the same engine, answering the same way, to whichever door you knock on.