The Problem

Developers building AI‑driven agents need a deterministic way to store, claim, and order tasks that may originate from many external systems (GitHub, Jira, Linear) or be created locally. Without a unified graph‑native backend, each integration must re‑implement dependency tracking, CAS‑style claims, and ready‑task detection, leading to duplicated effort and fragile coordination.

What This Does

Farm Table supplies a single runtime that normalises every task into a protobuf‑defined Normalized Task Object (see proto/farmtable/v1/farmtable.proto). The Go backend (internal/ and api/) implements a gRPC service (api/farmtable/v1/farmtable_grpc.pb.go) and an in‑process buffer‑connection mode for the CLI (cmd/ft/main.go).

The web dashboard (web/) is a React/Vite SPA that consumes the same service via gRPC‑web, with generated TypeScript types in web/src/gen/. Core store logic lives in the Ent ORM files (internal/store/ent/*.go), which persist tasks to SQLite (embedded) or Postgres (server mode).

Key entry points are:

  • cmd/farmtable-server/main.go – starts the gRPC server, creates the Ent store, and registers handlers.
  • cmd/decomposer/main.go – runs the task‑decomposition engine (internal/decomposer/engine.go) that calls the LLM model via MCP.

How It Is Wired

Execution begins in cmd/farmtable-server/main.go at func main(). It:

  1. Calls NewEntStore (via internal/store/ent/client.go:NewClient) → opens a DB connection (ent.Open), touching the filesystem and a database.
  2. Registers the gRPC service implementation (api/farmtable/v1/farmtable_grpc.pb.go) which routes RPCs to handlers in internal/mcp/server.go.
  3. Listens on the configured address (env FARMTABLE_SERVER or CLI flag).

When a client (CLI or web) invokes a task operation, the call follows the internal call graph:

  • Example – creating a task: handleTaskCreate (internal/mcp/server.go:299) → CreateTask (in internal/store/ent/task.go) → sqlSave → SetField (104 calls). This path touches 318 distinct functions and is a high‑blast‑radius hub.

The most widely referenced modules are the generated TypeScript hubs:

  • web/src/gen/types.ts – imported by 32 internal modules, no outgoing imports (instability 0).
  • web/src/gen/service.ts – imported by 18 modules, imports only one, low instability (0.05).

These files are critical for front‑end stability; changes here propagate widely.

The backend’s biggest single files are the protobuf generated code (api/farmtable/v1/farmtable.pb.go, farmtable_grpc.pb.go) and the monolithic server (internal/server/server.go), each exceeding 6 800 lines. Their size makes local reasoning difficult and increases the risk of regression.

No circular dependencies were detected among the 49 Go modules, but deep nesting (max depth 7) and high branching density appear in several conversion and store files, indicating complex decision logic that could be refactored.

How To Use It

# Clone the repository
git clone https://github.com/moses-y/farmtable.git
cd farmtable

# Build the Go binaries (Makefile provides targets)
make build        # builds cmd/farmtable-server and cmd/ft

# Run the server (embedded SQLite mode)
./bin/farmtable-server   # reads FARMTABLE_DB_PATH or defaults to ~/.farmtable/farmtable.db

# In another terminal, use the CLI
./bin/ft task list        # talks to the in‑process server via bufconn

To run the web dashboard locally:

cd web
npm ci                # installs from package-lock.json
npm run dev           # starts Vite dev server, proxies to the gRPC endpoint

Configuration is driven by environment variables (FARMTABLE_SERVER, FARMTABLE_DB_PATH) and the optional config.yaml (not present in the repo, so defaults are used). No additional secret files are committed.

Real‑World Use

An AI‑assistant that resolves bug tickets can invoke ft task ready to fetch ready tasks, claim one with ft task claim <id>, run the LLM to generate a fix, and push the result back via ft task update. All interactions happen through the same gRPC service, regardless of whether the tasks originated from GitHub issues or the internal graph store.

Code Health & Issues

  • Critical – golang.org/x/crypto@0.49.0 has CVE‑2026‑42508 (plus 26 other advisories). Must upgrade and commit updated go.mod/go.sum.
  • High – google.golang.org/grpc@1.80.0 (GHSA‑hrxh‑6v49‑42gf) and golang.org/x/net@0.52.0 (CVE‑2026‑25680) are vulnerable; upgrade required.
  • High – No CI pipeline; add a GitHub Actions workflow that runs make test && go vet && npm test.
  • High – No build gate for Docker images; create a workflow that builds Dockerfile/Dockerfile.server and validates the manifests.
  • Medium – Enable Dependabot or Renovate for Go and npm ecosystems.
  • Medium – Pin Docker base images by digest to avoid mutable base layers.
  • Medium – Add a non‑root USER to Dockerfiles to reduce container escape risk.

Additional observations: the repository includes a full test suite (65 test files) but lacks automated execution; the licence file is present (Apache 2.0). Documentation exists in .design/ and .agents/, but a top‑level README does not list all required commands.

The Bottom Line

Farm Table delivers a coherent, graph‑native task runtime with both embedded and client‑server modes, backed by a solid Go/Ent core and a React dashboard. However, the codebase contains several large, highly coupled files and critical dependency vulnerabilities that must be addressed before production use. Teams comfortable managing Go dependencies and adding CI pipelines will find it a useful foundation for AI‑agent task orchestration.