LG Salles

AI, sales, marketing and development

Desenvolvimento

AI agent orchestration: reclaim your attention

November 15, 2026

Video by David Ondrej · Original title: “L8 Principal's Agentic Engineering Setup (just copy him)”Subscribe to the channel

Why it matters

AI agent orchestration becomes useful when keeping track of work starts consuming the attention you need for product decisions. One agent is implementing a change, another is investigating a failure, and a third needs clarification. Execution happens concurrently, while the project map still lives in your head.

The part of Kun Chen’s setup I find compelling is the attempt to move that coordination into a system. He demonstrates one conversation for directing work, separate workers for execution, and ways to bring unresolved decisions back to the person responsible. I would borrow that division of responsibilities before adopting his terminal configuration.

For developers maintaining several projects, the practical question is how much supervision the arrangement removes. The five-day pilot below gives that question a measurable answer. It includes the effort of maintaining the orchestration itself, which is easy to overlook when an impressive demo becomes a permanent part of your workflow.

Key points

  • 06:24 Herdr provides terminal sessions that can be reached remotely. That supports continuity of access, while prioritizing the work remains a separate concern. The terminal version has its own official product page.
  • 08:31 Managing many sessions emerges as a source of cognitive overhead. Remembering each agent’s purpose, progress, and next action becomes a job. A larger collection of tabs can leave that responsibility with the developer.
  • 10:08 Firstmate delegates a status check while remaining available for further requests. Separating coordination from execution is the key behavior demonstrated here, also described in the project repository.
  • 11:45 Kun describes building trust through observation and incremental adjustments. Early delegation mistakes and conflicting tasks required changes. That experience supports expanding autonomy as the process becomes dependable.
  • 14:32 Lavish turns an architecture discussion into an interactive visual artifact. The intended benefit is easier human judgment and feedback. Its official documentation describes this collaboration loop around HTML artifacts.
  • 16:09 The coordinator must interpret references to earlier work and project decisions. Kun also describes rules for selecting workers and models. Available quota becomes one input to that routing decision alongside task requirements.
  • 22:09 Human involvement centers on expressing intent and resolving ambiguity. This depends on the coordinator recognizing which decisions it can make and which require the user’s judgment.
  • 30:44 Pi is presented as a preferred environment because it can be customized extensively. That raises a useful adoption question: how much work should you invest in adapting the environment to your preferences?
  • 35:40 Firstmate is presented as instructions and scripts that the agent can inspect and modify. My practical addition would be a change record: a coordinator adjustment can influence work across several projects later.
  • 39:26 The no-mistakes workflow validates changes in a separate environment through review, tests, and additional checks. The official project describes this validation before forwarding a change. Passing the process still leaves room for undiscovered defects.
  • 45:54 The discussion addresses spending too much time improving development tools. Kun describes experiencing that detour himself. Evaluating an orchestration setup therefore requires counting the hours spent maintaining it.
  • 51:51 AXI introduces the design of efficient interfaces for agents. The reported results apply to the author’s evaluated scenarios. The published principles and benchmarks provide starting points for local experiments rather than a universal verdict on CLI versus MCP.

How to apply

AI agent orchestration with an attention budget

I would start with the development environment you already know. Pick a familiar repository, small tasks, and one week of observation. The limits and example numbers below are a proposed evaluation method, not measured results from Kun’s setup.

Choose a deliverable with an observable acceptance condition. For example, fix a webhook handler that creates duplicate records when the same event arrives twice. Define the expected behavior and a way to reproduce it before assigning the task. This gives you something concrete to evaluate when the agent reports completion.

Run a five-day pilot

  1. Day 1: record your current workflow. Complete two tasks as usual. Track intervention time, interruptions, rework, and whether you accepted the result. Include time spent reconstructing context after switching conversations.
  2. Day 2: add one coordinator and one worker. Route requests through the coordinator. Keep a persistent record of the objective, owner, state, and next action. Check whether you can resume after closing the conversation without rebuilding the project map yourself.
  3. Day 3: allow two independent workers. Select tasks in separate areas. If both require the same unresolved decision or modify the same code, resolve that dependency before running them concurrently.
  4. Day 4: introduce a predictable blocker. In a test environment, provide a task with a missing requirement. Observe whether the coordinator identifies the missing information and asks a useful question. Repeated attempts without new information should appear in your record.
  5. Day 5: compare accepted work. Add supervision, final review, corrections, and orchestration maintenance. Compare tasks of similar difficulty. Record model usage or the corresponding charges alongside the human effort.

Make delegation explicit

An initial assignment could establish this working agreement:

Objective: prevent duplicate webhook processing. Acceptance: delivering the same event twice preserves the correct record count. Run at most two workers. Persist the objective, owner, state, and completion evidence. After two attempts without progress, report the blocker and recommend a next step. Bring product behavior changes back to me for a decision. Prepare the change for review before merging.

Refine the agreement when you observe a specific failure. For every additional rule, record the problem it addresses and how you will tell whether it helped. Otherwise, the instruction file becomes another growing system that demands attention.

Use states that communicate what someone should do next:

| State | Required information | Human action | |---|---|---| | Working | Objective and owner | None | | Blocked | Obstacle and missing input | Unblock | | Decision needed | Options and recommendation | Choose | | Ready for review | Change and supporting evidence | Accept or return |

Calculate human attention per accepted delivery

Divide human attention minutes by accepted deliveries. During the pilot, include the time spent configuring and repairing the orchestration. Track defects discovered after acceptance separately, so a rushed review cannot masquerade as an efficiency improvement.

Consider a hypothetical comparison. Your existing workflow produces six accepted deliveries using 90 minutes of attention: 15 minutes each. Orchestration produces eight using 140 minutes: 17.5 minutes each. Output increased, and each delivery also required more human effort. That tradeoff might make sense for a deadline, but it should be visible.

Also record how often work comes back because the requirement was misunderstood. A rise in that number suggests you should examine delegation and shared context before changing the implementation model. Keep task size visible too: a documentation correction and a database migration should not count as equivalent evidence of productivity.

Add tools in response to observed friction

If you keep losing sessions, evaluate session management. If architecture decisions disappear into long conversations, try a visual artifact. If tool responses bury relevant information, compare interfaces using the same task, model, and similar starting conditions.

Increase concurrency one worker at a time. For each addition, check whether it reduces supervision or improves accepted output without disproportionate rework. A dashboard full of activity can be satisfying, but my adoption criterion would be the time and attention left for building the product.

Resources mentioned

  • Firstmate · Código aberto; coordenador baseado em instruções, skills e scripts. Modelos podem gerar custos.
  • Herdr TUI · Versão de terminal demonstrada no vídeo; distinta do aplicativo Herdr atual.
  • WezTerm · Emulador de terminal usado no setup; nome distorcido na transcrição.
  • Pi · Ambiente extensível para agentes de programação; uso dos modelos pode ser cobrado.
  • Lavish · Artefatos HTML interativos para discutir planos e decisões com agentes.
  • no-mistakes · Validação de mudanças em worktree separado; execução dos agentes pode gerar custos.
  • AXI — Agent eXperience Interface · Princípios, catálogo de interfaces e benchmarks publicados pelo autor.
  • gh-axi · Interface para operações no GitHub projetada para agentes.
  • chrome-devtools-axi · Interface de automação de navegador apresentada na discussão sobre eficiência.
  • OpenCode · Agente de programação de código aberto; modelos e serviços opcionais podem ser pagos.
  • CodeRabbit (paid) · Patrocinador relacionado ao tema de revisão; oferece planos pagos e revisão gratuita para repositórios públicos.
  • Material do setup de Kun Chen · Material anunciado como gratuito; a página solicita nome e e-mail.