Fluxo de TrabalhoIntermediário

Roteamento de Tarefas Agente-Humano

Como decidir quais tarefas delegar a agentes versus manter para engenheiros humanos com base em risco, complexidade e disponibilidade de contexto.

Visão Geral

O Roteamento de Tarefas Agente-Humano é um framework de decisão para atribuir sistematicamente tarefas de desenvolvimento ao executor correto — agentes totalmente autônomos, agentes assistidos por humanos ou engenheiros humanos trabalhando sozinhos. O framework aplica o pilar de Engenharia Híbrida do Manual de Desenvolvimento Agêntico para construir uma matriz de roteamento que avalia cada tarefa em quatro dimensões: completude da especificação, cobertura de padrões, raio de impacto e novidade.

Sem um framework de roteamento, as equipes recorrem à intuição. Alguns engenheiros delegam em excesso, enviando trabalhos ambíguos ou de alto risco para agentes que consomem o Orçamento De Tokens sem produzir resultados utilizáveis. Outros delegam de menos, implementando manualmente tarefas que os agentes poderiam resolver em uma fração do tempo. Uma abordagem de roteamento estruturada maximiza a Razão De Alavancagem Do Operador ao direcionar cada tarefa ao executor mais bem equipado para lidar com ela.

A decisão de roteamento ocorre antes do início da execução do agente — durante a Daily Flow Sync ou o Bloco de Engenharia de Especificações semanal — e alimenta diretamente o processo de atribuição da Especificação Viva. O Núcleo Central (Arquiteto de Contexto, Gerente de Fluxo e Operador de Agentes líder) colabora nas decisões de roteamento, com o Gerente de Fluxo rastreando os resultados para refinar a matriz ao longo do tempo.

Problema

As equipes que adotam a Engenharia Agêntica enfrentam um problema persistente de alocação: quais tarefas os agentes devem realizar e quais os humanos devem assumir?

A superdelegação desperdiça tokens e tempo. Quando os agentes recebem tarefas com especificações vagas, falta de contexto ou alta novidade, eles produzem resultados de baixa qualidade que exigem extensa correção humana. A Taxa De Correção dispara. A frequência de Missão De Resgate aumenta. A equipe gasta mais tempo corrigindo a saída do agente do que gastaria escrevendo o código por conta própria.
A subdelegação desperdiça a capacidade humana. Quando os engenheiros implementam manualmente tarefas bem padronizadas e totalmente especificadas — endpoints CRUD, variações de componentes, geração de testes, documentação — eles deixam a capacidade do agente ociosa. A Razão De Alavancagem Do Operador estagna porque os humanos estão fazendo um trabalho que os agentes realizam com confiabilidade.
Falta de loop de feedback. Sem rastrear quais decisões de roteamento levaram a bons resultados e quais não levaram, a equipe não consegue melhorar com o tempo. As mesmas tarefas mal roteadas recorrem. Os mesmos engenheiros continuam resgatando as mesmas categorias de agentes travados.
Decisões inconsistentes. Diferentes membros da equipe aplicam diferentes modelos mentais para a atribuição de tarefas. Um engenheiro delega agressivamente; outro mal utiliza os agentes. A equipe carece de um vocabulário compartilhado para discutir as fronteiras de delegação.

Solução

Implementar uma matriz de roteamento quadridimensional que pontua cada tarefa e mapeia a pontuação para um dos três modos de execução:

Agente autônomo — O agente executa de forma autônoma com gates padrão de Harness De Avaliação. Envolvimento humano mínimo além da revisão final.
Agente assistido — O agente executa com monitoramento humano ativo. O Operador de Agentes revisa a saída em checkpoints e fornece correções durante a tarefa.
Somente humano — O engenheiro humano implementa a tarefa diretamente. O agente pode auxiliar em subtarefas (geração de testes, documentação), mas não é o dono da implementação.

As quatro dimensões de roteamento são:

Dimensão	Pergunta	Pontuação Baixa (1)	Pontuação Alta (5)
Completude da Especificação	Quão completa está a Especificação Viva?	Requisitos vagos, sem critérios de aceitação	Contrato comportamental completo, critérios de aceitação testáveis, escopo definido
Cobertura de Padrões	A base de código contém implementações similares?	Sem precedentes, inédito	Múltiplas Amostras De Ouro existem para este padrão exato
Raio de Impacto	Qual é o impacto se a saída estiver errada?	Quebra caminhos críticos, afeta dados de produção, implicações de segurança	Mudança isolada, facilmente revertida, sem dependências a jusante
Novidade	Quanto julgamento criativo é necessário?	Requer decisões arquiteturais, análise de trade-offs, requisitos ambíguos	Aplicação direta de padrões e regras conhecidos

Pontue cada dimensão de 1 a 5. Some as pontuações:

Pontuação Total	Decisão de Roteamento
16-20	Agente autônomo
10-15	Agente assistido
4-9	Somente humano

Implementação

Exemplos de Código

Complete Routing Integration

// scripts/task-router.ts
import { readFileSync } from "fs";
import { parse } from "yaml";

interface RoutingConfig {
  task_classifications: {
    auto_agent: TaskType[];
    assisted_agent: TaskType[];
    human_only: TaskType[];
  };
}

interface TaskType {
  name: string;
  spec_completeness: number;
  pattern_coverage: number;
  blast_radius: number;
  novelty: number;
  notes?: string;
}

interface TaskScore {
  specCompleteness: number;
  patternCoverage: number;
  blastRadius: number;
  novelty: number;
}

type RouteDecision = "auto-agent" | "assisted-agent" | "human-only";

function loadConfig(path: string): RoutingConfig {
  const raw = readFileSync(path, "utf-8");
  return parse(raw) as RoutingConfig;
}

function scoreToRoute(score: TaskScore): RouteDecision {
  if (score.blastRadius <= 1) return "human-only";
  if (score.specCompleteness <= 2) return "human-only";

  const total =
    score.specCompleteness +
    score.patternCoverage +
    score.blastRadius +
    score.novelty;

  if (total >= 16) return "auto-agent";
  if (total >= 10) return "assisted-agent";
  return "human-only";
}

function findSimilarTask(
  description: string,
  config: RoutingConfig
): { route: RouteDecision; match: TaskType } | null {
  const allTasks = [
    ...config.task_classifications.auto_agent.map((t) => ({
      ...t,
      route: "auto-agent" as RouteDecision,
    })),
    ...config.task_classifications.assisted_agent.map((t) => ({
      ...t,
      route: "assisted-agent" as RouteDecision,
    })),
    ...config.task_classifications.human_only.map((t) => ({
      ...t,
      route: "human-only" as RouteDecision,
    })),
  ];

  const descLower = description.toLowerCase();
  const match = allTasks.find((t) =>
    t.name.toLowerCase().split(" ").some((word) => descLower.includes(word))
  );

  if (match) {
    return { route: match.route, match };
  }
  return null;
}

// Usage
const config = loadConfig("task-routing-config.yaml");
const suggestion = findSimilarTask("Add new CRUD endpoint for orders", config);

if (suggestion) {
  console.log(`Suggested route: ${suggestion.route}`);
  console.log(`Based on: ${suggestion.match.name}`);
  console.log(`Notes: ${suggestion.match.notes || "None"}`);
} else {
  console.log("No matching classification found. Score manually.");
}

Routing Decisions Log

# routing-log.yaml — Track decisions for retrospective analysis
entries:
  - date: "2026-02-20"
    task: "Add pagination to /api/products endpoint"
    scores:
      spec_completeness: 5
      pattern_coverage: 5
      blast_radius: 4
      novelty: 5
    route: "auto-agent"
    outcome: "passed-first-attempt"
    correction_needed: false

  - date: "2026-02-20"
    task: "Implement OAuth2 PKCE flow"
    scores:
      spec_completeness: 4
      pattern_coverage: 2
      blast_radius: 1
      novelty: 2
    route: "human-only"
    outcome: "completed-by-human"
    notes: "Security-critical path, blast radius override"

  - date: "2026-02-21"
    task: "Refactor UserService to repository pattern"
    scores:
      spec_completeness: 4
      pattern_coverage: 3
      blast_radius: 3
      novelty: 3
    route: "assisted-agent"
    outcome: "completed-after-2-corrections"
    correction_needed: true
    notes: "Agent missed edge case in error handling"

Considerações

Benefícios

• **Higher token efficiency.** By routing only well-specified, well-patterned tasks to autonomous agents, teams avoid burning [[token-budget]] on tasks where agents are likely to fail. Token spend correlates with successful output rather than wasted retries.
• **Fewer rescue missions.** Systematic routing prevents the most common cause of [[rescue-mission]] escalations — agents receiving tasks they are not equipped to handle given the available context. When rescue missions do occur, the routing log helps diagnose why.
• **Humans focus on high-value work.** Engineers spend their time on architectural decisions, novel problem-solving, and security-critical implementations — work where human judgment adds the most value. Routine implementations flow to agents.
• **Measurable improvement over time.** The routing log creates a feedback loop. Teams can see which task types consistently succeed as auto-agent and which consistently require human intervention. Over months, the routing matrix becomes increasingly accurate.
• **Shared delegation vocabulary.** The four-dimension scoring system gives the team a common language for discussing task assignment. "This task scores 2 on pattern coverage" is more actionable than "I do not think the agent can handle this."

Desafios

• **Initial classification effort.** Building the task classification catalog and calibrating scores requires a time investment during the first two weeks. Start with 5-10 common task types and expand gradually.
• **Edge cases resist clean scoring.** Some tasks score well on three dimensions but poorly on one — a well-specified, well-patterned task with a high blast radius. The hard rules (blast radius override) help, but edge cases still require human judgment during the Daily Flow Sync.
• **Routing boundaries shift as context improves.** A task type that starts as "human-only" may become "assisted-agent" after the team builds relevant [[golden-samples]] and context. Review the classification catalog monthly to keep it current.
• **Over-reliance on the matrix.** The routing matrix is a decision aid, not a replacement for engineering judgment. If an experienced engineer's instinct conflicts with the matrix score, investigate why. The instinct may be incorporating a factor the matrix does not capture.
• **Requires consistent scoring.** Different team members may score the same task differently. Calibrate by scoring 10 recent tasks together as a team during the first Spec Engineering Block. Discuss disagreements to align on scoring standards.

Roteamento de Tarefas Agente-Humano

Visão Geral

Problema

Solução

Implementação

Define Routing Criteria

Create the Routing Decision Tree

Classify Task Types for Your Codebase

Set Up Routing in Your Workflow

Monitor and Adjust Using Metrics

Exemplos de Código

Considerações