engineering.uncountable.com  /  coding

Agents already write our code.

Not soon — today. Agents write, review, and merge most changes to this codebase, and building the system that does it is fast becoming the whole job.

Where we are

A routine change merges in seventeen minutes

A year ago it took twelve hours. Same repository, same standards, same tests.

Measure July 2025 July 2026
Median time from opened to merged 11.8 hrs 17 min
Merged within four hours 34% 82%
Pull requests written by an agent 0% 75%
Pull requests merged that month 1,639 13,899
91%of product changes merge with no human approval
83,000+pull requests opened in thirteen months
13production deploys scheduled every weekday
128agents running on their own schedules

Small changes are a solved problem. Come make the large ones routine too — we intend to automate everything from a one-line fix to a full product build.

One hour

A bug reported in Slack, merged in 67 minutes

One real afternoon. Two human actions: describing the bug, and replying “triage”.

00:00
Someone describes a display bug to Spot in Slack.
+3 min
Spot files a Jira ticket — reporter, linked thread, written summary, reproduction steps, expected versus actual behavior.
+5 min
A human replies “triage”. That is the last human action in the chain.
+15 min
Spot posts a diagnosis, naming the root cause down to the file and the missing condition, and rating its own confidence.
+31 min
It writes the fix. One commit, four files, ten lines.
+31 min
Pull request opened, carrying four screenshots from a live instance of its own branch — including the bug reproduced on the base branch first, against demo data, never a customer's.
+61 min
Rover reviews it and approves.
+67 min
Merged. Spot closes the ticket, citing the pull request.
67 minutes, start to finish No human wrote a line  ·  No human approved it

A third of bugs reported in Slack merge within four hours. A quarter of all our tickets now begin as someone simply talking in a channel.

The team

Our agents are colleagues, and we name them like it

Each one has a Slack handle, a GitHub account, and a Jira account. You @-mention them, they answer in the thread, they take assigned tickets, they appear in review as themselves. There is no console to learn.

Spot

Triages, investigates, writes the code

Picks up a problem wherever it gets mentioned, works out what is actually wrong, and opens the pull request.

Slack · GitHub · Jira

Rover

Reviews everything

Reads every pull request against the standards of whichever part of the codebase it touches, and certifies the safe ones to merge.

GitHub

Fido

Turns problems into plans

Shapes a report into work someone can finish, breaking down anything too large for a single pass.

Jira

Handing one a task

Mention it
Tag it in any channel it can see, exactly like tagging a person.
Keep talking
Once it replies in a thread it stays engaged there for a week, no tag needed.
React
A check mark dispatches an agent. A thumbs up signs off a change waiting on approval.

The platform

Circus

None of this is a script somebody wired together. It runs on a platform we built for creating agents, and extending it is the work.

Circus builds customizable agentic workflows, and its core stays independent of whatever consumes it. An ingress layer classifies every incoming Slack message, GitHub event, and Jira update. A control plane ranks and admits the work. A warm pool of running pods means no task waits on a cold start. A runtime hands each task its own isolated environment. An egress layer posts the result back wherever the conversation began.

It is deliberately model-agnostic, driving Claude Code, Codex, and opencode behind one interface and evaluating all of them against the same suite of real historical pull requests. Models change underneath us constantly. The platform is what compounds.

It is helpful to think of the Circus system as vendoring a platform. The Circus is responsible for defining and upholding a set of standards.
circus/packages/shared
an agent, in fullworkspace/background
---
cron_spec: "23 14 * * 1"
disabled: false
owner: "<engineer>"
memory_folder: "background/<job>"
---

# then the runbook, in plain English

Every scheduled agent is a file like this, with a named owner. Creating one is a pull request. Changing what an agent believes is a diff anyone can read.

What they all share

3,744standards the agents apply, each traceable to its origin
167per-directory instruction files, compiled not written
38skills, defined once, available to every agent
34engineers who own at least one running agent

The job

A fifth of what our engineers write is the machine itself

That share is climbing, and we expect building the agent system to become the majority of engineering here. Almost nowhere else is it a line item at all.

The product still gets built, faster than ever. But a fifth of everything our engineers ship goes into the machinery that instructs, reviews, and constrains the agents — and that is the part we expect to grow.

The leverage is why people stay. A fix here is rarely a patch; it is a change to what every agent knows, inherited by every run that follows. A good afternoon does not fix one bug. It retires a category of bug permanently.

What that work is

Design an agent
Decide what it owns, what it needs to see, and how you will know it worked.
Build the runtime
Extend Circus itself: ingress, scheduling, isolation, tracing, tool access.
Evaluate
Build the eval sets that decide which model we trust for which work.
Encode judgement
Turn what a good engineer knows into something an agent applies every time.

Starting here

You ship on your first day

Not a toy commit to prove the setup works. Something real, in production, that afternoon — and several more every day after.

Our engineers touch dozens of pull requests a week themselves, while the agents they spawn merge many more. The code you write moves up a level — policy engines, eval harnesses, diff analysis, schedulers, admission control — and there is more of it, not less.

The environment bootstraps itself, demo data included. Every pull request ships with a live instance of the platform running that branch, so reviewing means clicking a link — and you can take over a running agent session whenever you want the wheel.

The conventions for whatever you touch sit in the folder you are touching, compiled from everything the system has already learned. That holds for you exactly as it holds for an agent, and it is why people get productive here in days.

Onboarding itself is run by an agent. When your question exposes a gap in the documentation, closing that gap is part of the answer — so nobody hits the same wall twice.

The product

What all of it is building

Our customers are chemists, formulators, and materials scientists. Experiments carry uncertainty, units, provenance, and revisions — and no framework models that for you.

Backend
Python, Flask, SQLAlchemy, Alembic, PostgreSQL, Redis
Frontend
TypeScript, React, SCSS, Bun, Biome, Playwright
Infrastructure
Kubernetes, Helm, Terraform, AWS and Azure, self-hosted CI
Agent platform
TypeScript, NATS, every task in its own ephemeral pod
Observability
Datadog, Sentry, incident.io
Analysis
In-house machine learning and statistics over experimental data

Open roles

We hire new graduates directly onto this work

If the platform interested you more than the product, apply.