Syed Saqib AI-first. Full-stack. Forward-deployed. Data scientist.

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.

Role
Founder of the team's task-authoring kit; operator of a coordinator plus five Claude Code agents
Client
An enterprise data & AI platform company
When
Jun – Nov 2026
Tracks
Agentic & GenAI · Full-stack & FDE · MLOps · Evaluation

Clients anonymized, no task content. The numbers are mine; the secrets aren't.

// recorded Jul – Nov 2026

3,500+

Commits by the coordinator and five agents, under my direction

Jul – Nov 2026

// recorded May – Nov 2026

≈39%

of the whole team's RL tasks, delivered by me and the agent fleet I ran

May – Nov 2026

// recorded Jun – Nov 2026

8,000+

Commits in the shared kit I founded (68 Python tools, 17 agent skills)

Jun – Nov 2026

// recorded Jun – Nov 2026

~800x

Smaller agent traces before any model reads them (61 MB → ~19K tokens)

Jun – Nov 2026

How it fits together

The fleet: who does what

Hover or tap a box to see what it talks to.

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.

Want the walkthrough?

Code walkthroughs are available on request, within NDA limits. Email is fastest.

Email me +92-333-4141218 LinkedIn Upwork Résumé (PDF)