Under the hood
Anvil Coder consists of a coordinator that holds the plan and workers that each execute one work step. Between them sits a durable queue: if a worker dies, no step is lost. The domain logic knows neither database nor model nor queue, which is why every provider is replaceable.
The domain logic speaks exclusively through ports; the connections sit outside as adapters. That sounds like a textbook and has a very practical reason: the language model is replaceable without the domain logic ever noticing.
For you this means: the dependency on a single provider sits in one place, not spread across the codebase.
Each worker holds its working tree in its own pod; scaling happens in whole pods, not threads. The queue backlog drives the fleet: with no waiting work it drops to zero, under load workers are added.
Java 25 and Spring Boot 4 form the domain core, Angular with signals the cockpit and Astro this statically delivered site. PostgreSQL holds projects and configuration, MongoDB the append-only audit trail, Redis can take over the distributed run state, NATS JetStream is the queue. Kubernetes and Flux CD deliver the service; Keycloak, nginx, Prometheus, Grafana and Tempo cover identity, edge and observability.
Git integration runs through JGit. GitHub connects through your organisation's app installation, GitLab through OAuth 2.0 with PKCE (gitlab.com today), Bitbucket Cloud through OAuth 2.0. The AI layer wraps Anthropic, the Claude command line and OpenAI-compatible providers such as OpenAI, Groq, Gemini, Mistral and Ollama behind one shared port. Three optional, read-only MCP servers give the agent context from YouTrack, GitHub and a curated text corpus, isolated per organisation.
The public documentation contains the released concepts and guides; internal operations runbooks and credentials are not published.
Phases run one after another and have gates: requirements, architecture, implementation, reconciliation, test, verification, documentation, consistency.TaskSlices run in parallel within a phase.
This separation is the core: order is preserved where it matters and dropped where it only slows things down. A project is not finished sooner because someone types faster, but because more of it is built at the same time. How the gates work is explained underHow it works.
A slice counts as done only when its result is committed. If a worker dies before that, the slice is redelivered. If a slice sits unacknowledged, it counts as demand and a worker is scaled up.
Reads run through a separate operating mode of the same image. A coordinator restart therefore takes nobody's view of running orders away.