Farm Table MCP Server

Farm Table is an open-source task runtime for AI agents and provides its own Model Context Protocol server through the command ft mcp serve. Its primary source is the repository at github.com/scion-frontiers/farmtable. According to the project, Farm Table gives coding and execution agents a predictable interface for receiving work, understanding dependencies, and tracking progress. It is therefore not a general chatbot and not merely another ticket list. Its focus is agent orchestration and task management built around a graph-oriented work structure.

Task management as a shared work model

Farm Table normalizes work into a consistent task object. Tasks can contain a title, description, acceptance criteria, priority, type, assignees, due dates, start dates, relationships, and code context. The model can ingest tasks from GitHub, Jira, or Linear and can also use its own graph-native store. According to the provider, external identifiers, URLs, and other remote fields are preserved so that synchronization does not automatically discard the original platform context. Teams should keep the source and freshness of each task visible. An agent must not treat a task description as unlimited authority because external content can be stale, manipulated, or incomplete.

Dependencies and available work

The distinctive value is the directed task structure. Farm Table can find ready tasks, show dependency trees, calculate critical paths, and surface bottlenecks through downstream dependencies. A task is therefore not selected by priority alone. Blocking relationships, stage, start and due dates, and the collection that contains the task also affect availability. This is useful for agent teams working through dependent steps where two agents must not silently start the same work. The database and API should still be treated as the shared source of state; a chat summary is not a substitute for checking the current state again.

MCP tools and write actions

According to the source code, the built-in MCP server exposes tools for listing, reading, searching, creating, updating, claiming, and closing tasks. Additional tools return ready tasks, dependency trees, and critical paths. Task claiming uses an atomic compare-and-swap mechanism so competing agents do not silently take the same work. Updates can nevertheless change content, assignees, relationships, dates, and stages. Before any write action, review the agent, user, collection, expected version, change description, and authorization. Closing or moving a task should not happen solely because a chat message was interpreted automatically.

Embedded and server operation

In embedded mode, Farm Table uses a local SQLite store and runs as a single process, according to the README. This is practical for personal development environments and controlled tests, but it does not mean that data is automatically protected from the selected AI model or from backups. In client-server mode, a separate Farm Table server can use PostgreSQL for multiple agents. The operating organization must secure network exposure, TLS, and token configuration. API tokens, linked platform credentials, repository data, and task text should never be placed in prompts, logs, or public exports. Collections and user permissions should be limited as tightly as the workflow allows.

Who Farm Table is for

Farm Table is aimed at technically capable teams that want to organize agentic development with traceable tasks, dependencies, and state transitions. It can serve as a local runtime, an MCP bridge for compatible clients, and a foundation for a controlled multi-agent deployment. The README describes the current project as early and experimental. Installation, tests, data model, authentication, backups, and operational boundaries should therefore be reviewed before production adoption. The repository is licensed under Apache-2.0. The software is available as open-source software; infrastructure, PostgreSQL, hosting, connected platforms, and AI-model costs remain subject to the respective providers' terms.

Go 1.26.5 according to go.mod, Node.js 22 or newer for the web dashboard, optional PostgreSQL in client-server mode, and an MCP-capable AI client.

Clone the repository, verify the local prerequisites, and build the ft binary from the cmd/ft path. Start ft mcp serve in a controlled workspace for MCP use. Before server operation, define authentication, TLS, database, collection, and backup controls.

go build -o ft ./cmd/ft && ./ft mcp serve

According to the README, the local embedded mode needs no SaaS account. Client-server operation uses API tokens and should be protected with TLS and narrowly scoped user and collection permissions.

Tasks, collections, repository context, and relationships can be read or changed. Scope write tools such as create, update, claim, and close to the user, collection, and expected version before use.

Embedded mode stores data locally in SQLite; server mode can use PostgreSQL. Content from GitHub, Jira, Linear, and local tasks may contain confidential project or personal data. The model provider used by the connected client requires a separate review.

MCP write tools can change task stages, relationships, assignees, and dates. Protect API tokens, network access, and collections. External task text is untrusted input and must not replace authorization or confirmation.