---
title: A coding-agent factory
subtitle: One coordinator, five autonomous
Claude Code agents and a shared kit
that turned RL-task authoring into a
production line
slug: coding-agent-factory
hook: "I stopped writing every task myself and
started running a team of agents.
One rule: nothing ships without evidence."
role: Founder of the team's task-authoring
kit; operator of a coordinator plus
five Claude Code agents
employer: Turing (contract, remote)
client: An enterprise data & AI platform
company
period: Jun – Nov 2026
tracks:
- agentic-genai
- full-stack-fde
- mlops
- evaluation
tags:
- multi-agent orchestration
- Claude Code
- context engineering
- developer tooling
- CI quality gates
metrics:
- value: 3,500+
label: Commits by the coordinator and five
agents, under my direction
when: Jul – Nov 2026
- value: ≈39%
label: of the whole team's RL tasks,
delivered by me and the agent fleet I
ran
when: May – Nov 2026
- value: 8,000+
label: Commits in the shared kit I founded
(68 Python tools, 17 agent skills)
when: Jun – Nov 2026
- value: ~800x
label: Smaller agent traces before any
model reads them (61 MB → ~19K tokens)
when: Jun – Nov 2026
---
## Context
Same program as case study 01:
reinforcement-learning environments for an
enterprise data & AI platform company's
autonomous data agent. Every task is days
of work: a design, a data estate, a gold
answer, a grader, a probe round, 20 graded
runs and 15+ gates. One author working
serially ships a handful a week.
The team needed more tasks without a lower
bar. So I stopped being only an author and
became an operator.
## The problem
Throughput, without trading away rigor. More
precisely:
- **Isolation.** Parallel agents must not
trample each other's work, files or task
IDs.
- **Consistency.** Five agents have to follow
one process, not five interpretations of
it.
- **Trust.** An agent saying "done" is a
claim. Delivery needs proof.
- **Context.** A 20-run task produces about 61
MB of raw traces, about 15.4M tokens. No
model should read that, and none needs to.
## Constraints
- A platform cap of 12 concurrent agent
sessions across the whole team.
- One laptop, so a 3 GB free-memory floor for
the whole fleet.
- A shared, live data workspace that delivered
tasks depend on.
- The client's bar kept rising during the
program (case study 01).
## What I built
**The kit (founded 26 Jun 2026).** The team's
shared task-authoring kit, which grew with
the team to 8,000+ commits. It holds:
- **68 Python tools:** gates, validators, a
workspace census, trace analysis, delivery
assembly and dashboards. I was first
author of 48 of its 82 tracked tool
scripts.
- **17 agent skills**, mirrored byte for byte
for Claude Code and Cursor, with a checker
that keeps the two copies in sync.
- **2 pre-execution safety hooks.**
- **A 291-key policy file**, the single source
of truth for every tunable number. No
magic numbers hiding in prompts.
- **A 2.5 MB, 312-section engineering
knowledge base.**
**Context engineering, for real.** Agent
traces are parsed by code, never read raw
by a model. A 20-run task is about 61 MB
raw and about 19K tokens digested, roughly
800 times smaller. A hook blocks any raw
trace from entering a model's context, so
nobody (human or agent) can skip the
digest by accident.
**The fleet.** When the team moved to parallel
streams, I wrote the stream provisioning
script and runbook (31 Jul 2026). Then I
ran a coordinator plus five autonomous
Claude Code agents, each on a frontier
model with extended reasoning. Each agent
authored its own task end to end in its
own repo clone. I gave every go.
**The coordinator's tooling (22 scripts).**
- A fleet watcher that flags stale, wedged and
memory-starved agents.
- A delivery verifier that checks the pull
request, the 14 mandatory files, the 10 +
10 traces and the tracker row before I see
anything.
- A task-ID claim checker across four claim
surfaces, so two agents never build the
same task.
- A login keep-alive, plus tripwires for the
network, disk space and session age.
**Concurrency fixes.** I fixed a cross-process
race (18 Sep 2026) that could have run a
batch on the wrong model, and scheduled
the fleet inside the 12-session cap and
the memory floor.
**The login failure that wasn't.** After a
break, every authentication check went red
and the keep-alive reported all six
sessions as dead. The tools suggested a
re-login. That login is globally
exclusive, so it would have killed every
live batch. We checked the network first:
the wrong VPN was on, so the workspace's
IP allow-list was refusing the laptop. The
tokens were fine. We reconnected and
refreshed all six sessions at once: no
re-login, no lost batch. The tripwire had
stayed silent for five hours because it
tested token minting, which still works
behind an IP block. I rebuilt it around a
real workspace call, and the tools now say
"IP-BLOCKED" instead of suggesting the
wrong fix.
## How it fits together
Three layers. On top, a human: me, giving
every go and every final approval. In the
middle, a control plane: the coordinator
session and its watchers, claim checker
and delivery verifier. At the bottom, five
workers, each a Claude Code agent in its
own clone, building one task at a time.
The kit runs through all of it. Skills tell
every agent the same steps in the same
order. Hooks and the policy file set the
guardrails. Tools do the checking. Raw
traces flow from the workspace into code
that digests them; agents only ever read
the digest. A task reaches me only after
the gates pass and the delivery verifier
agrees.
## Stack
- **AI-assisted engineering:** Claude Code
(subagents, skills, hooks) on a frontier
model with extended reasoning, Cursor
(mirrored skills and rules).
- **Languages:** Python, PowerShell, Bash,
SQL.
- **Delivery:** Git and GitHub (`gh` CLI, PR
workflow, branch strategy), JSON Schema
validation, CI quality gates.
- **Runs and data:** a Playwright run harness,
the data platform's CLI and Python SDK,
the Google Sheets and Drive APIs for the
tracker and asset registry.
## Results
- **≈39% of the program's tasks delivered**,
including 54% of the final,
most-scrutinized batch and 13 tasks in the
final week.
- **3,500+ commits** by the fleet under my
direction.
- **A kit with 8,000+ commits** that became
the shared way of working for every
operator on the project.
- **Traces about 800x smaller** before any
model reads them.
- **Zero lost batches** in the login incident,
and a class of false alarm that now names
itself correctly.
## What I'd do differently
- **Monitor the thing users need, not the
thing that's easy to ping.** The quiet
tripwire was checking something that still
worked. Every health check should make a
real call from day one.
- **Test skills by behavior, not just by
bytes.** The sync checker kept 17 skills
identical across two tools. I'd add a tiny
task per skill that it must complete, so a
skill can't drift into being wrong in both
places at once.
- **One claim registry.** Four claim surfaces
needed a checker to reconcile them. One
registry would have needed none.
- **Design the operator's queue as carefully
as the agents.** Five agents in parallel
move the bottleneck to the human who
reviews and approves. My approval queue
was a to-do list. It should have been a
product.
## What I left out
This is client work under NDA. Not included,
on purpose:
- the client's name, product and internal
program and repository names;
- task content, the kit's code, the text of
the skills and hooks, and the policy
values;
- the knowledge base;
- the names of the models used for
calibration;
- anything from the delivery repositories,
trackers or traces.
## How to verify
- **LinkedIn project** "Multi-agent
coding-agent factory for RL environments"
(Turing, Jun – Nov 2026): the coordinator
plus 5 Claude Code agents, the 68-tool
kit, the 15+ CI quality gates and ~39% of
the team's tasks.
- **LinkedIn About:** the toolkit I founded
(8,000+ commits) and the ~800x trace
reduction (61 MB → ~19K tokens).
- **Employment check:** Turing, official title
Consultant, contract, Mar 2024 – present.
- **In an interview:** a walk-through of the
method, within NDA limits.
- **Code:** walkthroughs available on request.
Case study 02 · Turing (contract, remote) · Jun – Nov 2026
A coding-agent factory
One coordinator, five autonomous Claude Code agents and a shared kit that turned RL-task authoring into a production line
I stopped writing every task myself and started running a team of agents. One rule: nothing ships without evidence.
✓ Compiled from this page's own markdown.
Context
Same program as case study 01: reinforcement-learning environments for an enterprise data & AI platform company's autonomous data agent. Every task is days of work: a design, a data estate, a gold answer, a grader, a probe round, 20 graded runs and 15+ gates. One author working serially ships a handful a week.
The team needed more tasks without a lower bar. So I stopped being only an author and became an operator.
The problem
Throughput, without trading away rigor. More precisely:
- Isolation. Parallel agents must not trample each other's work, files or task IDs.
- Consistency. Five agents have to follow one process, not five interpretations of it.
- Trust. An agent saying "done" is a claim. Delivery needs proof.
- Context. A 20-run task produces about 61 MB of raw traces, about 15.4M tokens. No model should read that, and none needs to.
Constraints
- A platform cap of 12 concurrent agent sessions across the whole team.
- One laptop, so a 3 GB free-memory floor for the whole fleet.
- A shared, live data workspace that delivered tasks depend on.
- The client's bar kept rising during the program (case study 01).
What I built
The kit (founded 26 Jun 2026). The team's shared task-authoring kit, which grew with the team to 8,000+ commits. It holds:
- 68 Python tools: gates, validators, a workspace census, trace analysis, delivery assembly and dashboards. I was first author of 48 of its 82 tracked tool scripts.
- 17 agent skills, mirrored byte for byte for Claude Code and Cursor, with a checker that keeps the two copies in sync.
- 2 pre-execution safety hooks.
- A 291-key policy file, the single source of truth for every tunable number. No magic numbers hiding in prompts.
- A 2.5 MB, 312-section engineering knowledge base.
Context engineering, for real. Agent traces are parsed by code, never read raw by a model. A 20-run task is about 61 MB raw and about 19K tokens digested, roughly 800 times smaller. A hook blocks any raw trace from entering a model's context, so nobody (human or agent) can skip the digest by accident.
The fleet. When the team moved to parallel streams, I wrote the stream provisioning script and runbook (31 Jul 2026). Then I ran a coordinator plus five autonomous Claude Code agents, each on a frontier model with extended reasoning. Each agent authored its own task end to end in its own repo clone. I gave every go.
The coordinator's tooling (22 scripts).
- A fleet watcher that flags stale, wedged and memory-starved agents.
- A delivery verifier that checks the pull request, the 14 mandatory files, the 10 + 10 traces and the tracker row before I see anything.
- A task-ID claim checker across four claim surfaces, so two agents never build the same task.
- A login keep-alive, plus tripwires for the network, disk space and session age.
Concurrency fixes. I fixed a cross-process race (18 Sep 2026) that could have run a batch on the wrong model, and scheduled the fleet inside the 12-session cap and the memory floor.
The login failure that wasn't. After a break, every authentication check went red and the keep-alive reported all six sessions as dead. The tools suggested a re-login. That login is globally exclusive, so it would have killed every live batch. We checked the network first: the wrong VPN was on, so the workspace's IP allow-list was refusing the laptop. The tokens were fine. We reconnected and refreshed all six sessions at once: no re-login, no lost batch. The tripwire had stayed silent for five hours because it tested token minting, which still works behind an IP block. I rebuilt it around a real workspace call, and the tools now say "IP-BLOCKED" instead of suggesting the wrong fix.
How it fits together
Three layers. On top, a human: me, giving every go and every final approval. In the middle, a control plane: the coordinator session and its watchers, claim checker and delivery verifier. At the bottom, five workers, each a Claude Code agent in its own clone, building one task at a time.
The kit runs through all of it. Skills tell every agent the same steps in the same order. Hooks and the policy file set the guardrails. Tools do the checking. Raw traces flow from the workspace into code that digests them; agents only ever read the digest. A task reaches me only after the gates pass and the delivery verifier agrees.
Stack
- AI-assisted engineering: Claude Code (subagents, skills, hooks) on a frontier model with extended reasoning, Cursor (mirrored skills and rules).
- Languages: Python, PowerShell, Bash, SQL.
- Delivery: Git and GitHub (
gh CLI, PR workflow, branch strategy), JSON Schema validation, CI quality gates.
- Runs and data: a Playwright run harness, the data platform's CLI and Python SDK, the Google Sheets and Drive APIs for the tracker and asset registry.
Results
- ≈39% of the program's tasks delivered, including 54% of the final, most-scrutinized batch and 13 tasks in the final week.
- 3,500+ commits by the fleet under my direction.
- A kit with 8,000+ commits that became the shared way of working for every operator on the project.
- Traces about 800x smaller before any model reads them.
- Zero lost batches in the login incident, and a class of false alarm that now names itself correctly.
What I'd do differently
- Monitor the thing users need, not the thing that's easy to ping. The quiet tripwire was checking something that still worked. Every health check should make a real call from day one.
- Test skills by behavior, not just by bytes. The sync checker kept 17 skills identical across two tools. I'd add a tiny task per skill that it must complete, so a skill can't drift into being wrong in both places at once.
- One claim registry. Four claim surfaces needed a checker to reconcile them. One registry would have needed none.
- Design the operator's queue as carefully as the agents. Five agents in parallel move the bottleneck to the human who reviews and approves. My approval queue was a to-do list. It should have been a product.
What I left out
This is client work under NDA. Not included, on purpose:
- the client's name, product and internal program and repository names;
- task content, the kit's code, the text of the skills and hooks, and the policy values;
- the knowledge base;
- the names of the models used for calibration;
- anything from the delivery repositories, trackers or traces.
How to verify
- LinkedIn project "Multi-agent coding-agent factory for RL environments" (Turing, Jun – Nov 2026): the coordinator plus 5 Claude Code agents, the 68-tool kit, the 15+ CI quality gates and ~39% of the team's tasks.
- LinkedIn About: the toolkit I founded (8,000+ commits) and the ~800x trace reduction (61 MB → ~19K tokens).
- Employment check: Turing, official title Consultant, contract, Mar 2024 – present.
- In an interview: a walk-through of the method, within NDA limits.
- Code: walkthroughs available on request.