AgentField: a Go control plane that turns agent functions into REST endpoints

What AgentField actually solves

Most agent frameworks start from the agent. AgentField starts from the service boundary. The README frames the project as an open source control plane that makes agents callable by any service in your stack, listing frontends, backends, other agents and cron jobs. The claim is that agent logic written in Python, Go or TypeScript becomes production infrastructure: routing, coordination, memory, async execution and observability.

The intended user is a backend engineer who already ships APIs. If you are comfortable with the idea that a function has an address, AgentField asks you to extend that idea to agent functions. The README's own summary is that every function becomes a REST endpoint and the same code scales from one agent on a laptop to ten thousand in a single workflow, with the control plane handling fan-out, queues and retries.

That framing sets expectations the project then has to meet. A control plane is not a library. It is a process you run, upgrade and monitor, and its failure modes become your failure modes. Anyone evaluating AgentField should read it as infrastructure first and framework second.

How the control plane, SDKs and node IDs fit together

The repository is split into a `control-plane/` directory written in Go, an `sdk/` directory with Go and Python packages, and `examples/` containing Python, Go and TypeScript agent nodes plus trigger demos. A `desktop/` directory and a `deployments/` directory also exist at the top level. The README links separate SDK reference pages for Python, Go, TypeScript and a REST API, so the control plane is expected to be reachable over HTTP regardless of which SDK produced the agent.

The mechanism visible in the README's Python example is a decorator plus a node identity. You construct an `Agent` with a `node_id` and a `version`, then decorate an async function with `@app.reasoner(tags=[...])`. Calling `app.run()` is described as exposing a route of the form `POST /api/v1/execute/researcher.research`, where the path is built from the node id and the function name.

Fan-out happens through `app.call`, which takes a fully qualified name such as `f"{app.node_id}.research"`. In the example, sub-questions are dispatched with `asyncio.gather`, and each branch re-enters the same agent through the control plane rather than being invoked locally. That is the architectural decision worth noticing: recursion goes over the wire, which is what makes per-branch queueing, retries and tracing possible, and also what makes every branch a network hop with its own cost and failure surface. The example includes an explicit `depth` cap, which the comment describes as keeping fan-out bounded. The README does not describe a default cap, so bounding recursion appears to be the author's responsibility.

Installing AgentField and calling your first reasoner

The README gives a single install command that pipes a script from the project's site into bash. The same section states that the installer places the `aforge` coding harness beside the `af` binary in `~/.agentfield/bin`, and that this can be skipped with `--no-aforge`.

curl -fsSL https://agentfield.ai/install.sh | bash

On macOS the README says the installer also registers the control plane to start at login under launchd and adds a menu-bar icon. Two operational details are given: stop it with `af service stop` or the menu-bar icon, because a plain `kill` looks like a crash and it restarts; and `af service status` shows health and in-flight work. Installing with `--no-tray` skips the login item and tray entirely.

af service status
af service stop

The README's other entry point is prompt-driven. After installing, you paste a spec into a coding agent using a slash command. The README lists Claude Code, Codex, Gemini CLI, OpenCode, Aider, Windsurf and Cursor as supported hosts, and gives this example verbatim:

/agentfield Build a claims processor with risk scoring, pattern detection,
and human approval for low-confidence decisions.

The documented result is a Docker Compose stack wired end to end: the agent, the control plane and a REST API endpoint the README says you can paste and curl. Note that this path produces generated code you did not write. The README does not describe how to review, diff or re-generate that stack after the spec changes, which is a gap if you intend to keep the output under version control.

For a hand-written agent, the README's Python sample is the reference shape: an `Agent` with `node_id`, `version` and an `AIConfig(model=...)`, an `@app.reasoner` decorated async function, and `app.run()` at the bottom. The README does not show the pip package name or a virtualenv step, so treat the SDK reference page as the source for that.

Where AgentField is the wrong tool

The release history is the first limitation. The three most recent releases listed are `v0.1.138-rc.16`, `v0.1.138-rc.15` and `v0.1.138-rc.14`, all dated 2026-09-09. Every one is a release candidate on a `0.1.x` line. If your deployment process requires a stable tagged release, that is not what this repository is publishing right now. The patch numbers also move fast within a single day, which suggests the interface is still settling.

The second limitation is scope. AgentField is a control plane, so it assumes you want a control plane. A single script that calls a model once and prints an answer gains nothing from a queue, a trace store and a tray icon. The install path reinforces this: on macOS it registers a login item by default, which is a lot of system-level presence for someone who wanted to try a library.

The third is the prompt-to-stack flow. The README promises a production-ready multi-agent backend from one prompt, but it does not document what happens when the generated Compose stack drifts from your spec, how to roll it back, or how to reconcile a regenerated stack with local edits. Rollback is not described in the README at all. For a system that generates infrastructure, that is the question to ask before the second generation, not after.

Finally, recursion through `app.call` means a runaway fan-out is a distributed problem rather than a stack trace. The README's example caps depth manually. There is no documented global budget, and `af service status` is described as showing in-flight work, which is the right place to look when something is looping, but the README does not describe an automatic circuit breaker.

AgentField compared with LangGraph-style graph orchestration

The closest alternative approach is a graph framework such as LangGraph, which models an agent system as nodes and edges you declare explicitly. The difference is where the topology lives. In a graph framework the structure of the workflow is data: you build a graph, and the runtime walks it. In AgentField the structure is control flow inside a normal function. The README states the position directly: plain Python, Go or TypeScript functions, with no DSL, no YAML and no graph wiring.

That trade is real in both directions. AgentField's version lets you use `if`, loops, `asyncio.gather` and ordinary error handling, and it lets a reviewer read the orchestration as code. A graph framework gives you a topology you can inspect, visualize and modify without touching the agent's logic, and it can validate the shape of the workflow before it runs. If your team needs to hand a workflow diagram to someone who does not read Python, AgentField's README offers no equivalent artifact.

The second axis is the deployment boundary. Graph frameworks typically run inside your process. AgentField runs a separate Go control plane and exposes each reasoner as a REST route. That buys you language-agnostic callers, which is why the README can advertise Python, Go, TypeScript and REST SDKs at once. It costs you a process to operate. If you are already running Kubernetes, the `deployments/` directory and the `cloud-native` and `kubernetes` topics suggest the project expects that environment. If you are not, you are adopting a control plane to avoid adopting a control plane.

Maintenance, versioning and the Apache-2.0 licence

The repository is not archived, and the last push was on 2026-09-09. That is recent activity, and it is the only maintenance signal available here. The version discipline is worth weighing separately: an `0.1.x` line publishing release candidates is a project that has not made a stability promise. The `VERSION` file at the repository root and the `.goreleaser.yml` configuration indicate a deliberate release process, and `CHANGELOG.md` exists, so the raw material for tracking changes is present even if the version number is young.

The licence is Apache-2.0, stated in the README badge and in the `LICENSE` file. Apache-2.0 is a permissive licence with an explicit patent grant, and it does not require you to publish modifications. What it does require, and what your own legal review should confirm, is that you preserve the licence and notice files when you redistribute. AgentField installs a control plane that runs as a service and, on macOS, starts at login. If you ship that to customers, the notice obligations travel with the binaries. This is a description of the licence text, not legal advice.

Upgrade cost is the part the README does not cover. There is no documented migration path between control plane versions, and no statement about whether the control plane's data survives an upgrade. The repository has a `Makefile` with a `build` target that compiles `control-plane` and `sdk/go` and installs `sdk/python` in editable mode, plus `test`, `lint`, `fmt`, `tidy` and `clean` targets, so building from source is supported. What is missing is what happens to in-flight workflows when the control plane restarts, and that is the first thing to test in a staging environment.

Editorial conclusion

Adopt AgentField if you already think in services and want agent logic reachable over HTTP without writing queue, retry or trace plumbing yourself, and if a release candidate version number does not block you. Skip it if you want a stable tagged release, a single-process script, or a visual graph editor. Before committing, verify three things in your own environment: that `af service status` reports healthy after install, that the generated Docker Compose stack exposes the REST endpoint the README describes, and that the control plane's persistence and upgrade story match what `control-plane/` actually implements.

Frequently asked questions

Official sources

1. Agent-Field/agentfield on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases