CONTACT US
CONTACT US

Agentic AI at Scale: A Practical Guide to One Engineer’s Autonomous Development Workflow

How a senior engineer moved from writing code to supervising a fleet of autonomous AI agents — and what that revealed about productivity, cost, and governance at scale.

At a glance

  • Client
An enterprise software client
  • Industry
AI & Machine Learning
  • Solution Provided
Autonomous, self-coordinating multi-agent workflows that pick up tickets, implement changes, and open pull requests, paired with a self-built monitoring dashboard for visibility
  • Technologies Used
Claude Code with custom skills; Model Context Protocol (MCP) integrations with Figma, Playwright, Slack, Atlassian, and Sentry; a self-built multi-agent orchestration environment; a self-built monitoring dashboard
The Challenge

Before adopting agentic workflows, work on the client’s frontend team followed a familiar AI-assisted pattern: write the code in an editor, ask a chat assistant for suggestions, and review everything himself. Moving past that stage meant learning to trust automation — letting models fail on purpose, watching where, and fixing the rules around them. That progression has been the operating rhythm for the last two years, with working practices changing again roughly every couple of months.

As adoption and output grew, cost and oversight became harder to manage. Token usage across the client is a free-for-all, with no hard cap on AI usage — what draws attention is low usage, not high, since it signals someone isn’t getting value from the tools. In practice, that meant very high, largely unmonitored spend in places: one Principal-level engineer opens 1,000+ pull requests a month; individual monthly token costs on this engineer’s team — including his own — climbed well into five figures, largely from automated processes reviewing other people’s (and other systems’) work.

At the same time, the volume of agent-driven work grew dramatically — in a single month of 2026, the team opened more pull requests than it did in all of 2024 combined, and overall volume increased 8.5x from 2024 to 2026 year-to-date — to the point where the team could no longer review every decision an agent makes — a bad call might only surface once it visibly breaks something. Rising cost, rising volume, and a fast-moving, permissions-based culture with no firm governance rules created real pressure for a more deliberate, supervised system rather than an unmanaged one.

The Solution

Gorilla Logic’s engineer built an autonomous, self-coordinating agent layer that goes well beyond AI-assisted coding. The agent layer can pick up tickets, find context, coordinate work, implement changes, create pull requests, provide before/after screenshots, and stop when human input is needed. It can also generate its own work — picking up signals from Slack or Sentry, converting them into Jira tickets, and resolving them autonomously. This engineer’s own role shifted from writing and reviewing code to supervising and maintaining the agent layer, stepping in mainly for the hardest, most ambiguous work.

How It Works

  • His self-built, local multi-agent environment: 19 scheduled processes (not agents themselves) sense signals from Jira, GitHub, and Slack and file them as “beads” into a shared work queue, built on a database called Dolt. Those processes trigger roughly 150 agent runs on weekdays and 15 on weekends.
  • Two dispatch lanes split the work — an implementation lane and a review lane — each on its own schedule, so they never compete for capacity. Headless Claude Code workers do the actual implement/fix/review/QA work and write their output as artifacts rather than touching GitHub directly.
  • One component, the review-verdict-joiner, is the only part of the system allowed to write to GitHub, gating on findings, CI status, and peer review state. A deny list of sensitive paths (core, API, scripts, CI config, etc.) is never auto-approved, regardless of findings — those always require a human.
  • Built-in guardrails keep the system honest: watchdogs confirm agents are alive and producing, admission control checks machine load and power before starting work, and garbage-collection routines clean up stale claims and state.
Visibility and Cost Discipline
  • A read-only dashboard he built himself to track queue state, agent health, his pull requests, and code review activity.
  • To address rising costs, he began keeping a daily log of his own token spend and the changes he makes to bring it down.
Keeping Production Safe
  • The system isn’t fully autonomous — agents pause and wait whenever they hit something that needs a human call. Production is protected by a deliberately manual boundary: because of the client’s security requirements, nothing from day-to-day agent work reaches production automatically, giving the team a safer layer to experiment aggressively without that risk reaching production.
Technology Used
  • Claude Code with custom skills; Model Context Protocol (MCP) integrations with Figma, Playwright, Slack, Atlassian, and Sentry; the self-built multi-agent orchestration environment; a self-built monitoring dashboard.

The Results

When a teammate went on paternity leave, the mechanical, agent-driven work kept flowing with no need to backfill his role — the profiled engineer simply absorbed a bigger queue of judgment calls himself, which took more time but kept things manageable.

The daily tracking discipline paid off, at least for a while: this engineer’s optimization work cut his own monthly token cost significantly over two months, without losing output — but the volume of code he was responsible for reviewing has since roughly doubled, pushing his spend back up and turning cost control into an ongoing cycle rather than a one-time fix. He also notes that uneven spend across the team creates friction, since some people spend heavily while others barely go past their base allowance.

What’s Still Unresolved
  • Measuring ROI: Cost is tracked closely, but not how much of it comes back as value — easier to prove on work tied to a specific client than on speculative work for prospective ones, where he says there’s a “huge asterisk.”
  • Quality at scale: The team still can’t review every agent decision; they let it flow and assume it’s working until something visibly breaks.
  • Fragility of automation: Small changes ripple unpredictably — one code review policy update caused real chaos across the workflows the same week.
  • Ownership & governance: Still unresolved. The client’s permissions-based culture predates AI, but AI lets any one person trigger far more change than firm rules can keep up with.

AI adoption at this client isn’t a single leap — it’s a two-year pattern of the way of working changing every couple of months, with no fixed end state in sight, and the engineer expects the next shift within about two months.

Ready to Scale AI Adoption the Right Way?

Gorilla Logic helps engineering teams move from AI-assisted coding to supervised, autonomous workflows — without losing control of cost, quality, or governance along the way.