Um Desenvolvedor, Cinco Terminais, Zero Consciência

É 23h e eu tenho quatro terminais abertos.

Um está rodando uma sessão do Claude Code na refatoração de autenticação. Outro está em um worktree do git, reconstruindo os testes. Um terceiro está revisando um pull request. Um quarto está apenas... lá, esperando, porque eu sei que vou precisar dele em dez minutos. Em algum lugar na mistura, há uma pequena equipe de sub-agentes se espalhando em uma migração.

Não estou fazendo isso porque gosto do caos. Estou fazendo isso porque é assim que "produtivo" parece agora.

Se você entrega software com agentes de IA, você já conhece essa sensação. Um agente trabalhando em uma tarefa, do início ao fim, é muito lento. Então você divide o trabalho. Você abre uma segunda janela. Depois uma terceira. Você cria um worktree para que duas branches possam avançar ao mesmo tempo. Você entrega um lote de tarefas independentes a uma frota de sub-agentes e deixa que eles rodem. O paralelismo é a única alavanca que resta quando uma única sessão não consegue acompanhar o tamanho do que você está tentando fazer.

E funciona — até que não funcione.

O ponto cego do paralelismo

Veja, a coisa que ninguém te diz quando você começa a rodar sessões em paralelo: cada uma dessas sessões é uma ilha.

A Sessão A está profundamente no módulo de autenticação. Está lá há vinte minutos, na metade de uma refatoração, arquivos abertos, mudanças não confirmadas. Três minutos depois, a Sessão B — um processo completamente separado, em um terminal completamente separado — também alcança o módulo de autenticação. Não porque é imprudente. Porque ela não tem ideia de que a Sessão A existe.

Agora você tem dois agentes editando o mesmo código sem conhecimento um do outro. Um sobrescreve as suposições do outro. Um conflito de merge brota do nada. Ou pior — sem conflito, apenas duas ideias inacabadas entrelaçadas silenciosamente no mesmo arquivo, e você não percebe até que os testes fiquem vermelhos por razões que não fazem sentido.

Você perde exatamente o tempo que o paralelismo deveria ter economizado. Essa é a armadilha. Quanto mais rápido você vai dividindo o trabalho, mais área de superfície você cria para que as divisões colidam — porque nenhuma delas pode ver as outras.

Comecei a chamar isso de ponto cego do paralelismo. Você adicionou mais mãos para se mover mais rápido, e as mãos não conseguem se ver.

A memória resolve "o que aconteceu." Isso é "o que está acontecendo."

Se você usou ContextForge, você sabe que ele já dá aos seus agentes uma memória que sobrevive a cada sessão — as decisões, as correções, as restrições, carregadas de uma sessão para a próxima para que seu agente pare de esquecer a sexta-feira até segunda-feira.

Mas a memória durável responde a uma pergunta sobre o passado: o que aconteceu antes. O ponto cego do paralelismo é uma pergunta completamente diferente — uma pergunta sobre agora:

Quem mais está trabalhando nisso, neste momento, enquanto eu estou?

A memória é história. Isso é presença. A história de uma sessão te diz o que ela fez ontem; não te diz nada sobre a sessão que está rodando no terminal ao lado neste segundo. Nenhuma quantidade de "lembrar o que aconteceu" conserta "eu não consigo ver o que está acontecendo."

Essa é a lacuna. E por um tempo, foi uma lacuna que eu só percebia parcialmente — porque quando é apenas você e um terminal, ela não existe. Ela só aparece quando você está profundo o suficiente no trabalho paralelo para ser mordido por ela.

O comentário que a nomeou

Então um leitor deixou um comentário em um dos meus posts que a nomeou exatamente.

Ele apontou que o ContextForge cobria a história de uma única sessão lindamente — memória que persiste — mas que o caso de múltiplas sessões estava completamente aberto. Quando você roda dois ou mais agentes contra o mesmo projeto, não há uma camada de estado compartilhado ao vivo. Nada que permita que a Sessão A levante a mão e diga "Eu estou com o módulo de autenticação agora" para que a Sessão B não entre nele.

Lendo isso, senti aquela dor particular de um bom feedback: a coisa óbvia que você de alguma forma não havia deixado a si mesmo ver. Eles estavam certos. A memória entre sessões estava resolvida. A consciência entre sessões não estava. Agora tinha um nome, e uma vez que algo tem um nome, você tem que construí-lo.

Então eu fiz.

Presença de Sessão: um "quem está aqui" ao vivo para seus agentes

A nova funcionalidade se chama Presença de Sessão, e toda a ideia cabe em uma frase: suas sessões paralelas agora podem se ver em tempo real.

Aqui está como isso realmente funciona, porque a melhor parte é o quão pouco você precisa fazer:

• Ela se registra. Cada sessão do Claude Code (ou Cursor, ou qualquer cliente MCP) automaticamente se anuncia como ativa na primeira vez que faz algo. Você não executa um comando. Você não pensa sobre isso. No momento em que uma sessão começa a trabalhar, ela está no quadro.
• Ela se mantém honesta. Cada sessão envia um batimento silencioso a cada poucos minutos. Assim, a lista é sempre de sessões ativas — não um cemitério de coisas que você fechou horas atrás. Uma sessão que morre sem se despedir simplesmente desaparece sozinha.
• Ela desaparece de forma limpa. Quando você fecha uma sessão, ela é removida imediatamente — mesmo no segundo antes do processo ser totalmente encerrado. Nenhum fantasma antigo permanecendo na lista.

Além disso, três pequenas ferramentas dão voz ao agente:

• session_update — "Estou trabalhando no módulo de autenticação." Uma sessão declara em que está focada.
• session_list — "Quem mais está neste projeto agora, e o que estão fazendo?"
• session_end — "Terminei aqui."

E você não precisa memorizar nada disso. Você apenas fala. Pergunte ao seu agente, em inglês simples, "tem mais alguém trabalhando neste projeto agora?" — e ele verifica o quadro e te diz: sim, outra sessão está no módulo de autenticação há alguns minutos; você pode querer evitar.

Uma coisa mais que importa: é consultivo, não um bloqueio. A presença é um sinal de "ocupado" em uma porta, não uma chave que a tranca. Não impede você de fazer nada — apenas garante que você nunca está fazendo isso cegamente. Você permanece no controle; você apenas pode tomar a decisão com a imagem completa em vez de metade dela. E está restrito ao projeto em que você realmente está, então uma tarde ocupada em cinco repositórios diferentes não se torna ruído — você vê as sessões que podem realmente colidir com a sua, e nada mais.

Como se sente na prática

Voltando àquela cena das 23h. Duas sessões, ambas se aproximando do módulo de autenticação.

Com a presença, a segunda pergunta ao quadro antes de mergulhar. Ela vê que a Sessão A já está lá, focada exatamente nisso. Então, em vez de colidir, ela pega os testes — a outra coisa na lista que ninguém está tocando. Sem conflito. Sem ideias entrelaçadas. Sem 30 minutos perdidos desatando um emaranhado que nunca precisava acontecer.

Essa é a grande vitória. Não é chamativo. É a diferença silenciosa entre cinco sessões trabalhando próximas uma da outra e cinco sessões trabalhando cegamente uma ao lado da outra.

Experimente esta semana

Se você já está rodando sessões paralelas — worktrees, equipes de agentes, três terminais antes do almoço — isso é para você.

1. Atualize para a versão mais recente do ContextForge MCP. A Presença de Sessão é lançada na versão atual e funciona com Claude Code, Cursor e Copilot através do MCP — então mesmo que você transite entre todas as três ferramentas em um dia, suas sessões ainda se veem.