---
titel: "Technology"
adresse: https://anvil-coder.tech/en/technology
beschreibung: "Anvil Coder is a hexagonally built application of two deployables connected through NATS JetStream — the coordinator holds the execution graph, the workers process the atomic steps. The worker side scales horizontally; how many run side by side is a deployment decision, in the hosted service it is one today."
sprache: en
---

Under the hood

# How the system is built

Anvil Coder is a hexagonally built application of two deployables: a coordinator that holds the execution graph, and workers that process the atomic work steps — the worker side is laid out horizontally and takes any number side by side. They are connected through NATS JetStream, a durable queue — no work step is lost when a worker dies.

## Why hexagonal

The domain logic knows neither database nor language model nor queue. It 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 a buyer this means: the dependency on a single provider sits in one place, not spread across the codebase.

## The building blocks

**Coordinator**

Holds the execution graph, distributes the slices and merges the results. It is the only place that knows the overall plan.

**Worker**

Takes exactly one TaskSlice, executes one AI prompt, validates and commits. The design allows any number side by side; how many actually run is a deployment decision.

**NATS JetStream**

The durable queue in between. A slice is not lost when a worker dies — it is redelivered.

**query-svc**

A second operating mode of the same image for reads. Views survive a coordinator restart because of it.

Scaling horizontally is a property of the design, not a statement about today's operation: as long as a worker keeps its working tree inside its own pod, the hosted service runs exactly one. More throughput therefore means detaching the working tree from the pod first — and only then raising the ceiling.

## What it is built with

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 and NATS JetStream is the durable queue between coordinator and workers. Kubernetes and Flux CD deliver the hosted service; Keycloak, nginx, Prometheus, Grafana and Tempo cover identity, edge and observability.

- Java

- Spring Boot

- Angular

- Astro

- PostgreSQL

- NATS

## Tools and interfaces

Git integration runs through JGit. Connections go through the organisation's confirmed GitHub app installation, for GitLab through OAuth 2.0 with PKCE (gitlab.com today), for Bitbucket Cloud through OAuth 2.0. The AI layer wraps Anthropic, the Claude CLI or agent-service and OpenAI-compatible providers such as OpenAI, Groq, Gemini, Mistral and Ollama behind one shared port. Three optional, read-only MCP servers deliver YouTrack, GitHub and curated documentation context to the agent, tenant-isolated.

The public [documentation](https://anvil-coder.tech/docs) contains the released concepts and guides; internal operations runbooks and credentials are not published.

## Two axes that cross

**Phases** run one after another and have gates — REQUIREMENTS, ARCHITECTURE, IMPLEMENTATION, RECONCILIATION, TEST, VERIFY, DOCUMENTATION, CONSISTENCY; two of them are optional (RECONCILIATION and VERIFY) — off in the default delivery, switched on in the hosted service.**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.

## What happens when something fails

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 *(optional)*.

Reads run through a separate operating mode of the same image. A coordinator restart therefore takes nobody's view of running orders away.

## Want to go deeper?

If you have an architecture review ahead of you, we are happy to walk through the parts that matter for your case together.

[Start for free](https://app.anvil-coder.tech/register)[Book a demo](https://anvil-coder.tech/demo)