Quem executa
→ esta task?

A pergunta que organiza o AIOX não é 'qual prompt', é 'quem executa esta task'. São quatro respostas possíveis, e jogar IA em tudo é o erro mais caro do iniciante.

4 executoreshumano, agent, clone, worker
1 perguntaquem executa esta task?
5 tasksclassificadas no portão da aula
Legenda de coresOs 4 executores e a tese que os sustenta
Humano
Agent
Clone
Worker
IA pra tudo

Mapa da aula

Use este mapa para entender a sequência da aula antes de entrar nos detalhes.

Legenda de coresOs 4 executores e o anti-padrão
Humanojulgamento e aprovação que não se delega
AgentIA com persona para raciocínio e linguagem
Clonepreserva a voz e o jeito de uma pessoa
Workerscript determinístico, barato e confiável
IA pra tudojogar agent em task que um worker resolve melhor

A task é o centro, o executor é escolha

No AIOX a unidade fundamental é a task, não o agente. Toda task tem inputs, outputs, pré-condições, pós-condições e, separadamente, um executor. Trocar o executor não muda a task.

A regra que sustenta a aulaPrimeiro a task fica de pé: o que entra, o que sai, como sei que deu certo. Só depois você pergunta quem executa. A task validada é lei; o executor é uma decisão que você revê sem reescrever a task.

Mentalidade IA-primeiro

  • Joga toda task num agent de IA por reflexo.
  • Paga token e aceita variância até em tarefa mecânica.
  • Acha que mais IA é sempre mais capacidade.
  • Usa IA pra contar item de uma lista.

Mentalidade task-primeiro

  • Define a task primeiro, depois escolhe o executor.
  • Manda tarefa mecânica para um worker determinístico.
  • Reserva o agent para raciocínio e linguagem.
  • Conta a lista com um script, sem variância.
Adriano de Marqui (host T2, t2-aula-6)A pergunta-chave é: quem executa essa tarefa? Tem gente usando IA pra contar lista. Worker é determinístico, é mais barato, e pra muita coisa entrega melhor que o agent.

O caminho da aula

Três movimentos: entender os 4 executores, ver o caso da task que estava no executor errado, e classificar tasks suas por critério.

Os 3 movimentos

1. Os 4 executoreshumano, agent, clone, worker e quando usar cada um
2. Executor erradoa task na IA que pedia um worker
3. Classificarrodar a pergunta 'quem executa' nas suas tasks

[ a ] Você vai sair sabendo

  • O critério de uso de cada um dos 4 executores.
  • Por que worker bate agent em tarefa mecânica.
  • Como diagnosticar uma task no executor errado.

[ b ] Você vai sair fazendo

A classificação de 5 tasks do seu trabalho entre humano, agent, clone e worker, com justificativa.

O ritmo da escolha de executorTrês batidas antes de jogar qualquer task na IA.
1Define a taskinputs, outputs, como sei que deu certo
2Pergunta quem executahumano, agent, clone ou worker
3Justifica por critériojulgamento, raciocínio, persona ou determinismo

Quem executa esta task?

O eixo de decisão operacional do AIOX. Quatro perguntas em cascata levam a um dos quatro executores.

Quem executa esta task?

Comece pela natureza da task, não pela ferramenta que você gosta.

Humano

A task exige julgamento, decisão de risco ou aprovação que não se delega.

signal

Worker

A task é mecânica, determinística, com regra clara e zero ambiguidade.

action
↓ ↓ ↓

Clone

A task exige a voz, o estilo ou as heurísticas de uma pessoa específica.

bench

Agent

A task exige raciocínio aberto ou linguagem, sem precisar de uma persona específica.

insight
↓ ↓ ↓

Você escolheu o executor pela natureza da task, ou pela ferramenta que tinha à mão?

Se a resposta foi 'agent' por reflexo, refaça pela natureza da task.

O reflexo que custa caroJogar IA em tudo parece moderno. Em tarefa mecânica é mais caro, mais lento e mais incerto que um worker. A IA introduz variância onde você queria garantia.
Cluster 1 / 4task é o centro, executor é escolha · os 4 executores · a pergunta quem executa

Você tem o eixo de decisão. Agora vê o caso de uma task que estava no executor errado e o que mudou.

Caso Real

A task que estava na IA e pedia um worker

Contar e validar uma lista parecia trabalho de IA. Era trabalho de worker. A troca de executor cortou custo e variância sem mudar a task.

Parar de usar IA pra contar lista

Quando a task é mecânica, a IA é o executor caro e incerto. O worker entrega o mesmo resultado sempre, por uma fração do custo.

Rota · action
Começou comoTask de contar e validar itens de uma lista delegada a um agent de IA.
VirouA mesma task movida para um worker determinístico (script), com saída idêntica a cada execução.
ProvaO agent às vezes errava a contagem ou variava o formato. O worker nunca varia.
LiçãoMudar o executor não muda a task. Muda o custo e a confiabilidade.
SituaçãoUm operador joga toda automação num agent de IA, inclusive contar e validar listas. Funciona na maioria das vezes, mas custa token e às vezes varia.
DecisãoReconhecer que a task é determinística e mover para um worker. A task continua a mesma; só o executor muda.
EvidênciaAdriano aponta ao vivo: tem gente usando IA pra contar lista. Worker é determinístico e mais barato.
Mensagem ao alunoAntes de pedir pro agent, pergunte se um worker resolve. Se a regra é clara, é worker.
ContextoEm t2-aula-6, Adriano formaliza os 4 executores e usa o contraste do worker para quebrar a ideia de que tudo precisa de IA.
Percepção-chaveA task tem inputs, outputs e critério de aceitação fixos. Se a transformação é determinística, o executor certo é o worker, não o agent.
DecisãoClassificar a task pela natureza, mover para worker, e reservar o agent para o que exige raciocínio.
1Sintomacusto de token alto e variância numa task simples.
2Diagnósticoa task é mecânica e tem regra clara. Não precisa de IA.
3Trocamesma task, executor vira worker (script determinístico).
4Resultadosaída idêntica sempre, custo perto de zero, zero variância.
Determinísticoworker entrega a mesma saída sempre
Token zeroscript não paga por execução de modelo
Mesma tasksó o executor mudou, não o contrato
AntesAgent de IA contando lista. Caro e às vezes errado.
DepoisWorker determinístico. Barato e sempre igual.
LiçãoDeterminismo onde dá; IA onde precisa de raciocínio.
Adriano de Marqui (host T2, t2-aula-2)Os executores são intercambiáveis. A task é a mesma. Você pode trocar quem executa: agent, worker, clone, humano. O worker determinístico é o que mais gente esquece que existe.

O custo de cada executor por tipo de task

O mesmo tipo de task tem custo, variância e velocidade diferentes em cada executor. Escolher errado paga caro em escala.

ExecutorCusto por execuçãoVariânciaQuando usar

Humano

Custo por execuçãoalto (tempo)
Variânciaalta
Quando usarjulgamento e aprovação

Agent

Custo por execuçãomédio (token)
Variânciamédia
Quando usarraciocínio e linguagem

Clone

Custo por execuçãomédio (token)
Variânciamédia
Quando usarvoz de uma pessoa

Worker

Custo por execuçãoquase zero
Variâncianula
Quando usartarefa mecânica
Onde cada executor entrega melhor (adequação por tipo de task)
  • Tarefa mecânica no worker
    95%
  • Tarefa mecânica no agent
    40%
  • Raciocínio aberto no agent
    90%
  • Decisão de risco no humano
    100%
Cluster 2 / 4task no executor errado · worker vs agent em tarefa mecânica · custo por executor

Você viu o custo do executor errado. Agora vê a técnica: as camadas da decisão e o pipeline de classificação.

Trilogia

WHY / WHAT / HOW da escolha de executor

As 3 camadas que sustentam a decisão. Pular a primeira faz você escolher executor por hábito, não por critério.

1

WHY - A task é lei, o executor é variável

Se a task está bem definida, trocar o executor não quebra nada. Isso libera você a escolher o mais barato e confiável para cada caso, em vez de pagar IA por reflexo.

WHYtask-first
2

WHAT - Quatro executores, quatro naturezas

Humano para julgamento. Agent para raciocínio e linguagem. Clone para a voz de uma pessoa. Worker para o que é mecânico e determinístico.

WHAT4 executores
3

HOW - Classificar pela natureza da task

Pergunte se a task exige decisão humana, persona específica, raciocínio aberto ou regra determinística. A resposta nomeia o executor. Justifique sempre.

HOWclassificar

O fluxo: da task ao executor

A sequência que leva uma task definida até o executor certo, sem pular pela ferramenta favorita.

Da task definida ao executor justificado

1

Task definida

inputs, outputs e critério de aceitação no papel.

2

Natureza

a task é julgamento, raciocínio, persona ou regra mecânica?

3

Executor

humano, agent, clone ou worker, conforme a natureza.

4

Justificativa

registra por que esse executor, não outro.

A sequência de classificação

Os passos concretos para classificar uma task entre os 4 executores em uma sessão real.

◇▶ signal_plus_action

Classificar o executor de uma task

Use antes de delegar qualquer task nova a um agent por reflexo.

definir→perguntar→classificar→justificar
  1. definir — Escreva a task: o que entra, o que sai, como sei que deu certo.
  2. perguntar — Exige decisão humana? Persona específica? Raciocínio? Ou é regra mecânica?
  3. classificar — Nomeie o executor: humano, clone, agent ou worker.
  4. justificar — Escreva em uma frase por que esse executor e não outro.
Worker é a primeira pergunta, não a últimaAntes de pensar em agent, pergunte se um worker resolve. Se a regra é clara e a saída é determinística, é worker. A IA fica para o que tem ambiguidade real.

Não confunda os executores

Três confusões comuns que levam a escolher o executor errado e pagar por isso em escala.

Não confundaWorker, não agent barato

Worker é um script determinístico, não uma IA mais simples.

Esclareça: Worker não raciocina e não varia. É código. Para regra clara, é superior ao agent.

Não confundaClone, não agent genérico

Clone carrega a voz e as heurísticas de uma pessoa específica.

Esclareça: Agent tem persona genérica. Clone preserva o jeito de alguém. Use clone quando o jeito importa.

Não confundaHumano, não gargalo a eliminar

Humano é o executor de julgamento e aprovação, por design.

Esclareça: Nem todo humano no loop é ineficiência. Decisão de risco e sign-off são tasks de humano.

1

Regra clara e saída fixa

executor = worker.

2

Raciocínio aberto, sem persona

executor = agent.

3

Precisa da voz de alguém

executor = clone.

4

Julgamento ou aprovação

executor = humano.

Pipeline: definir-classificar-justificar

As 4 fases que transformam uma intenção de automação em uma task com executor certo e justificado.

1. Definir a task

Escreve inputs, outputs, pré e pós-condições e critério de aceitação. A task fica de pé sozinha.

Fase 1 · Outputtask.yaml com contrato completo
Fase 2 · GateA task se explica sem citar quem executa?

2. Classificar a natureza

Decide se a task é julgamento, raciocínio, persona ou regra mecânica.

Fase 1 · Outputnatureza-da-task: humano | agent | clone | worker
Fase 2 · GateA natureza foi decidida pela task, não pela ferramenta?

3. Justificar o executor

Registra em uma frase por que esse executor, e não outro, é o certo.

Fase 1 · Outputjustificativa-executor.md
Fase 2 · GateVocê consegue defender a escolha contra a alternativa mais óbvia?

4. Revisar na escala

Quando a task roda muito, revisita: dá pra mover de agent para worker e cortar custo?

Fase 1 · Outputlog de revisão de executor
Fase 2 · GateTasks de alto volume já foram avaliadas para worker?
Cluster 3 / 4trilogia WHY/WHAT/HOW · fluxo da task ao executor · sequência de classificação · pipeline definir-classificar-justificar

Você tem a técnica. Agora vê o ferramental: os 4 executores em grade, as mecânicas de troca e os KPIs.

Grade

Os 4 executores em grade

Cada executor com sua natureza, seu custo e seu caso de uso. A grade que você consulta antes de delegar.

Humano◇ signal

Julgamento, decisão de risco, aprovação. Ponto de controle por design.

Agent✦ insight

IA com persona. Raciocínio aberto e linguagem, sem precisar do jeito de alguém.

Clone▲ bench

Preserva voz e heurísticas de uma pessoa. Para tarefas que exigem o jeito dela.

Worker▶ action

Script determinístico. Tarefa mecânica, regra clara, custo perto de zero.

Matriz determinismo x necessidade de raciocínio

Os quatro quadrantes que apontam o executor.

Determinístico + sem raciocínio

Worker. Regra clara, saída fixa.

Não determinístico + raciocínio

Agent. Ambiguidade real, linguagem.

Não determinístico + precisa de persona

Clone. O jeito de alguém importa.

Decisão de risco

Humano. Julgamento e aprovação.

Mecânicas de troca de executor

O operador amadurece movendo tasks para o executor certo. Cada transição tem uma mecânica concreta.

Agent para Worker▶ action

Reconhece que a task é determinística e escreve o script. Corta token e variância.

Agent para Clone▲ bench

Percebe que a voz de uma pessoa importa e troca o agent genérico por um clone.

Worker para Humano◇ signal

Identifica que a regra esconde uma decisão de risco e devolve para julgamento humano.

Tudo-IA para task-first✦ insight

Para de delegar por reflexo e passa a classificar cada task pela natureza.

1. Motor do determinismo

Toda task com regra clara é candidata a worker antes de qualquer IA.

taskregra clara?workercusto zero

2. Motor do raciocínio

Ambiguidade real e linguagem aberta pedem agent, não worker.

taskambígua?agentraciocínio

3. Motor do julgamento

Decisão de risco e aprovação ficam com humano, por design.

taskrisco?humanosign-off

KPIs da escolha de executor

Os indicadores que separam o operador que classifica do operador que joga IA em tudo.

Tasks mecânicas em worker
acima de 80%40% a 80%abaixo de 40%
Justificativa de executor registrada
sempreàs vezesnunca
Token gasto em tarefa determinística
perto de zeromoderadoalto
KPITudo-IAClassificadorMaduro

Tasks mecânicas em worker

Tudo-IA0%
Classificadormaioria
Madurotodas

Custo por automação

Tudo-IAalto
Classificadorbaixo
Maduromínimo

Variância em tarefa mecânica

Tudo-IAalta
Classificadorbaixa
Maduronula

Executor justificado

Tudo-IAnunca
Classificadorquase sempre
Madurosempre
Cluster 4 / 4grade dos 4 executores · matriz determinismo x raciocínio · mecânicas de troca · KPIs

Ferramental visto. Agora a adoção e a prática: você vai classificar 5 tasks suas entre os 4 executores.

Adoção

Como adotar sem virar dogma

Classificar executor não pode virar planilha infinita. Adote pelo volume e pelo custo da task, começando pelas que mais rodam.

Não faça

  • Classificar executor de toda task trivial e isolada.
  • Manter agent caro numa task mecânica de alto volume.
  • Tratar humano no loop sempre como gargalo.

Faça

  • Classificar primeiro as tasks que mais rodam e mais custam.
  • Mover para worker o que é mecânico e roda muito.
  • Manter humano onde a decisão é de risco real.

Prática: classifique 5 tasks

Pegue 5 tasks recorrentes do seu trabalho e classifique cada uma entre humano, agent, clone e worker, com justificativa.

aula.yaml9 linhas
01# Preencha antes de delegar. Uma entrada por task recorrente.02tasks: 03  - task: "{o que a task faz, em 1 frase}"04    entra: "{inputs}"05    sai: "{outputs}"06    criterio_aceitacao: "{como sei que deu certo}"07    natureza: "{julgamento | raciocinio | persona | mecanica}"08    executor: "{humano | agent | clone | worker}"09    justificativa: "{por que esse executor e nao outro}"

Produz

Trecho copiável para executar ou adaptar.

Portão

Template da classificação (uma linha por task)
Portão da aulaAntes de seguir para a próxima aula: você classificou 5 tasks suas entre os 4 executores e escreveu uma justificativa para cada escolha. Se alguma task mecânica de alto volume ficou no agent, reveja antes de passar.
  1. Liste 5 tasks: Escreva 5 tasks recorrentes do seu trabalho que hoje você delega ou faz na mão.
  2. Defina cada uma: Para cada task, escreva o que entra, o que sai e como você sabe que deu certo.
  3. Pergunte a natureza: Para cada task: é julgamento, raciocínio, persona ou regra mecânica?
  4. Nomeie o executor: Classifique cada task como humano, agent, clone ou worker.
  5. Justifique: Escreva uma frase por task explicando por que esse executor e não outro.

Glossário

Os termos desta aula em uma frase cada.

Executor

Quem executa uma task: humano, agent, clone ou worker. É uma escolha separada da task.

Humano

Executor de julgamento, decisão de risco e aprovação. Ponto de controle por design.

Agent

IA com persona genérica, para raciocínio aberto e linguagem.

Clone

Executor que preserva a voz e as heurísticas de uma pessoa específica.

Worker

Script determinístico para tarefa mecânica. Barato, confiável, sem variância.

Task-first

Definir a task antes de escolher o executor. A task é lei; o executor é variável.

Próxima aulaVocê já decompõe o agente e sabe escolher o executor. A partir daqui, M2 cuida do setup operacional: janela de contexto, engenharia de contexto e o formato certo para cada artefato.