Você começa com um terminal e o Claude Code. Depois chega uma segunda tarefa, então você abre um segundo terminal e inicia o Codex nela. Um ajuste no frontend vai para um terceiro. Agora você está alternando entre três janelas com Alt+Tab, tentando lembrar qual delas está esperando por você, qual fez uma pergunta há dez minutos e qual terminou silenciosamente e está parada enquanto você queima atenção nas outras duas. Nada está pegando fogo. Mas você se tornou a peça que distribui o trabalho entre os agentes, e essa função escala pior do que qualquer um deles.
Os terminais não são o custo. Você é. Quando os agentes rodam manualmente, toda decisão sobre o que acontece a seguir mora em um único lugar: na sua cabeça. Qual agente recebe a próxima tarefa, se o último diff é seguro, o que falhou enquanto você lia uma janela diferente. Essa coordenação é trabalho de verdade, não é remunerada, e cresce mais rápido do que o número de agentes que você adiciona.
Este artigo detalha o que realmente custa rodar agentes de programação manualmente, onde a conta se esconde até se acumular e qual é o fluxo de trabalho que elimina a maior parte disso. O Sharkly é a camada de gestão que fica acima dos seus agentes: você mantém o Claude Code, o Codex ou qualquer runtime que já usa, e o Sharkly concentra as tarefas, o isolamento e a revisão em um único lugar compartilhado, em vez de espalhá-los por uma parede de terminais.
TL;DR
Rodar agentes de programação manualmente parece gratuito porque nenhuma ferramenta cobra por isso. O custo real é a sua atenção: você se torna o roteador entre os agentes, a memória do que cada um está fazendo e o único revisor que precisa se atualizar sobre cada janela. Esse custo permanece pequeno com dois ou três agentes e se acumula a partir de cinco. Você pode continuar fazendo isso manualmente ou encaminhar seus agentes atuais por uma camada de tarefas como o Sharkly, que atribui trabalho, isola cada execução e devolve cada resultado a uma Tarefa para revisão.
Os terminais não são o problema, você é
Eis uma definição que vale guardar: um terminal é onde um agente roda; uma tarefa é o trabalho no qual ele roda. Quando você gerencia agentes manualmente, nada conecta os dois além de você. O terminal mostra a saída. Ele não sabe qual era a tarefa, se ela terminou ou quem decide o que acontece a seguir. Você fornece tudo isso de memória, uma janela por vez.
É por isso que "terminais demais" é um sintoma, não a doença. Dividir um agente em cinco painéis com o tmux não reduz a coordenação; apenas a organiza. Você ainda carrega o mapa de qual painel é dono de qual tarefa, qual está em execução e qual terminou e precisa que um humano dê uma olhada. O mapa não vive em nenhum lugar compartilhado, então, no momento em que você se afasta, ele fica desatualizado, e, no momento em que um colega precisa dele, ele não existe.
O que realmente custa rodar agentes manualmente
A conta é paga em atenção, e a atenção tem um preço mensurável. Quando você alterna entre tarefas não relacionadas, não retoma instantaneamente. Pesquisas sobre trabalho intelectual interrompido de Gloria Mark e colegas, publicadas na CHI 2008, descobriram que as pessoas levam, em média, mais de vinte minutos para retomar uma tarefa interrompida depois de serem puxadas para outra coisa. O resumo da American Psychological Association sobre pesquisas de alternância de tarefas estima a perda de produtividade da troca entre tarefas em até 40 por cento. Toda vez que um agente termina e você gira para uma janela diferente, você paga alguma versão desse imposto.
Rodar agentes manualmente transforma essa troca no seu loop principal. Eis onde o custo se acumula:
| Custo oculto | Como aparece no modo manual | Por que se acumula |
|---|---|---|
| Roteamento | Você decide, de memória, qual agente recebe cada nova tarefa | Mais agentes significa mais combinações para manter na cabeça |
| Recarregamento de contexto | Você relê cada terminal para lembrar o que ele estava fazendo | Cada troca reinicia o relógio para voltar a se concentrar naquela tarefa |
| Desvio de estado | Cada terminal carrega sua própria branch, seu ambiente e edições pela metade | Duas tarefas no mesmo diretório se corrompem silenciosamente |
| Fila de revisão acumulada | Você é o único que viu cada execução acontecer | Trabalho concluído espera pela única pessoa que pode revisá-lo |
| Nenhum registro compartilhado | O status vive na sua sessão, não em algum lugar que um colega possa ver | Afaste-se e o progresso fica invisível; ninguém consegue assumi-lo |
Nenhum desses custos aparece como um travamento. Eles aparecem como um dia que pareceu cheio e produziu três PRs mesclados em vez de oito, sem nenhum momento específico que você possa apontar como o problema.
Os modos de falha se escondem até se acumularem
Com dois agentes, você consegue manter o mapa inteiro na memória de trabalho e o custo é quase zero. Vale dizer isso claramente, porque é onde a maioria dos conselhos exagera o problema: se você roda um ou dois agentes em uma máquina e revisa cada um antes de começar o próximo, ainda não precisa de uma camada de gestão. Mantenha as peças móveis em zero.
A equação muda quando o trabalho se sobrepõe no tempo ou no estado. Rode três agentes no mesmo checkout e você cai no problema de isolamento abordado em vários agentes de programação no mesmo repositório: dois agentes tocam os mesmos arquivos, e um sobrescreve o outro silenciosamente. Resolva isso com um worktree por tarefa, a disciplina de worktrees de agentes de programação, e você troca um problema de merge por um problema de contabilidade: qual diretório corresponde a qual tarefa, qual é seguro excluir, qual está em revisão por um humano. Resolva isso com mais terminais e você volta ao ponto de partida, só que com mais janelas.
O último custo é o mais silencioso. Quando cada execução acontece em um terminal privado, o trabalho concluído não tem para onde ir além da sua atenção. A revisão se torna o gargalo, porque você é a única pessoa que viu o agente trabalhar e a única que pode dizer se o diff é bom. Agentes em paralelo não ajudam se a revisão da saída deles se serializa em um único humano. Essa é a armadilha descrita em por que o melhor agente de programação importa menos do que como você os gerencia: o modelo ficou mais rápido, e sua fila de revisão, não.
O que a camada de gestão elimina
Um quadro de tarefas elimina a parte que você fazia manualmente: ser o tecido conjuntivo entre os agentes e o trabalho. No Sharkly, a Tarefa é a unidade que é dona da execução. Você atribui uma Tarefa a um Agente, e o Sharkly prepara um worktree isolado para ela em um Computador conectado, roda a sessão do agente ali e devolve o diff, os logs e quaisquer bloqueios àquela Tarefa. O roteamento, o isolamento e o registro que você mantinha na cabeça passam a ser propriedades da Tarefa.
Isso mantém a divisão do trabalho clara. Os agentes pesquisam, executam, testam e reportam; as pessoas definem a direção, concedem autoridade e aceitam o resultado. O Sharkly não substitui o Claude Code, o Codex ou o runtime que você já usa; são eles que fazem a execução. Ele adiciona a tarefa compartilhada, o Computador conectado e a camada de revisão ao redor deles, para que contexto, progresso, bloqueios, resultados e revisão humana permaneçam visíveis da solicitação até a entrega, em vez de espalhados por cinco sessões que só você enxerga. Quando você precisa acompanhar várias execuções ao mesmo tempo, é para isso que um dashboard de agentes realmente serve, e é por isso que as equipes acabam querendo a camada acima do Claude Code e do Codex, em vez de mais um terminal.
Se você já roda vários agentes, esse é o fluxo de trabalho em torno do qual o Sharkly foi construído. Você pode continuar roteando manualmente entre terminais, ou rodar seus agentes de programação atuais pelo Sharkly e deixar o quadro manter o mapa.
Quando o modo manual funciona, e quando não funciona
A regra de decisão honesta é curta:
- Rode agentes manualmente quando você tem um ou dois, em uma máquina, e revisa cada um antes que o próximo comece. A sobrecarga de qualquer ferramenta ainda não vale a pena.
- Migre para uma camada de tarefas quando um terceiro agente entra em cena, o trabalho abrange mais de um repositório, ou alguém além de você precisa ver o que está rodando. Esse é o ponto em que o custo de coordenação deixa de caber na cabeça de uma só pessoa.
O sinal não é o número de terminais. É o momento em que você se pega perguntando "espera, em qual janela era isso?". Essa pergunta é o imposto de coordenação se manifestando como uma frase, e é o mesmo caos de agentes que um quadro de tarefas existe para acabar.
Perguntas frequentes
O tmux ou um multiplexador de terminal não basta? Ele organiza as janelas; não elimina a coordenação. Você ainda carrega qual painel é dono de qual tarefa, o que terminou e quem revisa. Um multiplexador resolve espaço na tela. O custo de rodar agentes manualmente é atenção, não pixels.
Quantos agentes consigo rodar manualmente antes de começar a doer? A maioria das pessoas fica bem com um ou dois e começa a sentir por volta de três a cinco, especialmente em mais de um repositório. O número exato depende de quanto tempo cada tarefa roda e de quanta revisão cada uma exige. O sinal é quando rotear e reler janelas ocupa mais do seu dia do que a revisão em si.
Um quadro de tarefas deixa meus agentes mais rápidos? Não, e o Sharkly não afirma isso. Os agentes rodam na mesma velocidade. O que muda é a sua sobrecarga: roteamento, isolamento e revisão deixam de viver na sua cabeça e passam a retornar a uma Tarefa, onde o trabalho fica visível e revisável.
E quanto a manter o contexto entre sessões? Terminais privados perdem o contexto no momento em que você os fecha. Vincular uma execução a uma Tarefa mantém o objetivo, o diff e a discussão juntos, o que resolve o problema de manter o contexto entre sessões no nível do registro, em vez de pela memória.
Posso continuar usando o Claude Code e o Codex juntos dessa forma? Sim. O Sharkly gerencia o trabalho em torno das ferramentas; não as substitui. Veja como rodar o Claude Code e o Codex juntos para conhecer o padrão.
