Cortex: pare de ser o índice das suas próprias conversas com a IA

Quem usa um assistente de IA para programar por algumas semanas acaba com o mesmo problema: uma pilha de conversas e uma única pessoa que sabe o que tem em cada uma — você.

Todo o contexto da tela de configurações está no chat de terça. A migração do banco de dados foi discutida em outro. O dos testes ficou pela metade. Cada tarefa nova começa por uma decisão que não produz nada: em qual conversa eu entro? Se errar, paga o contexto de novo — literalmente, porque cada explicação repetida são tokens que saem do seu bolso.

O trabalho de arquivista era você quem fazia. O Cortex é esse trabalho feito pelo app.

O resumo em uma frase

O Cortex é um novo modo do chat de IA do PocketCode em que você deixa de falar com um assistente e passa a falar com um coordenador: você entrega o trabalho e ele o distribui entre várias conversas especializadas que trabalham ao mesmo tempo, sem se atropelar, e que devolvem decisões agrupadas em vez de interrupções soltas.

A ideia de fundo: um agente é uma conversa

Esta é a parte que vale ler duas vezes.

Na maioria dos sistemas "multiagente", um agente é uma chamada de um disparo só: nasce com uma instrução, faz a sua coisa e morre. Não lembra de nada. No dia seguinte você explica o projeto outra vez.

No Cortex, cada agente é uma sessão de chat completa e viva: histórico próprio, memória própria, ferramentas próprias, modelo próprio e provedor próprio. Exatamente igual a uma conversa normal do app. A única diferença é de quem ele recebe ordens: não recebe mensagens suas, recebe tarefas do coordenador, e responde a ele.

A consequência prática é a que vende o modo: o agente que cuida da sua interface já cuida dela há semanas. Ele sabe como você chama as coisas, o que você decidiu em julho e por que descartou a outra opção. Não precisa colocar ninguém a par.

E você pode entrar em qualquer uma dessas sessões quando quiser: é uma conversa de verdade, lê-se inteira, e ali você pode escrever diretamente. Não é uma caixa-preta.

Onde ele se encaixa: não substitui nada

O PocketCode já tinha duas coisas parecidas, e as três convivem:

	Unidade de trabalho	Quanto vive	Para que serve
AI Office	um projeto inteiro	uma sessão, e termina	gerar um projeto do zero, de uma vez
Swarmcode	um turno de um chat	morre com o turno	uma tarefa pesada resolvida por muitos olhos anônimos
Cortex	uma conversa com contexto	dias, semanas	seu trabalho em andamento, dividido por tema

O Cortex cobre a lacuna do trabalho contínuo, que é onde se passa a maior parte do tempo real.

Como funciona

Liga-se com um interruptor, e muda a interface inteira

Não é mais uma opção do seletor de modos do chat. É trocar de marcha: a tela do chat é substituída pela do Cortex. Sai-se com um toque, e ao sair você volta exatamente para a conversa que estava olhando.

Na primeira vez há uma tela de boas-vindas, uma só, onde você escolhe o nível de autonomia. Não três adjetivos: cada opção vem com um exemplo concreto do que o Cortex decidiria por conta própria.

Você entrega o trabalho em linguagem normal

A caixa de texto sempre fala com o coordenador. Isso é uma garantia, não um detalhe: você nunca escreve para um agente por acidente. Frases como "isso é para o de interface", "não mexa no modo escuro" ou "deixa, isso eu faço" são mensagens normais que o coordenador interpreta e distribui.

Ele divide, e te mostra a divisão

Antes de gastar um centavo, o coordenador quebra a tarefa, decide qual pedaço é de quem, evita que dois agentes escrevam no mesmo arquivo ao mesmo tempo e ordena o que depende de outra coisa. E conta isso em uma linha legível:

"Vou dividir em dois: a tela fica com o de interface, o endpoint com o de backend. Não se atropelam."

Com um link para ver o plano completo, se te interessar.

O detalhe que dá confiança: o pareamento entre tarefa e agente é resolvido primeiro com lógica local, no celular, sem chamar nenhum modelo. Quando é resolvido assim, o app diz isso explicitamente: 0 tokens. O coordenador pensar não pode custar dinheiro por padrão.

Se não há agente para aquilo, ele pergunta antes de trabalhar

"Para isso eu tenho o agente de layout, mas ele não faz refatorações. Crio um de refatoração de interface com estas ferramentas e este modelo, ou vou com o de layout?"

Com dois amortecedores para que a pergunta não custe tempo: a opção recomendada já vem marcada — um toque e segue — e a ficha do agente proposto é expansível, não um formulário. Nome, modelo, ferramentas e escopo à vista; você só mexe se quiser mudar algo. E há um criador de agentes completo para quem quiser fazer à mão, com um botão + sempre visível.

O que você vê ao voltar 20 minutos depois

Esta é, por projeto, a tela que decide se o modo agrada ou não. Não a do trabalho em andamento: a da volta, no ônibus. Três coisas, nesta ordem:

1. Um cabeçalho: "2 coisas esperam por você" — ordenadas por quanto trabalho cada uma desbloqueia, não por antiguidade.
2. Um resumo compactado: "Refatoração de interface · 4 arquivos · 2 decisões eu mesmo tomei · 1 subtarefa para o backend". Cada pedaço se expande.
3. O feed completo abaixo, para quem quiser ler tudo.

Se você tinha saído do app, chega também uma notificação com esse mesmo texto.

A tira de agentes

Abaixo da barra há uma tira horizontal com um cartão por sessão viva. Tocar entra na conversa dela. Três faixas de cor e nada mais:

Cor	Significa
Lima	vai sozinho, não faça nada
Âmbar	espera por você
Cinza / vermelho	dormindo / quebrou

Um detalhe de design que explica bem a filosofia: na fila é rotulado como na fila e não leva rodinha girando — mas vai em verde-lima, porque não está esperando por você, e essa é a única pergunta que a cor responde.

Regra dura autoimposta: zero ações obrigatórias na tira. Tudo pode ser feito a partir da conversa com o coordenador. No momento em que houver algo que só possa ser feito entrando em um agente, o modo vira gestão de equipe — que é justamente o trabalho que ele veio tirar de você.

As perguntas chegam agrupadas, não pingando

A pergunta de um agente não sai disparada. Fica retida até o primeiro destes três eventos: o agente ficar sem mais nada para fazer, passarem uns 45 segundos sem novas perguntas, ou o agente produzir o seu resultado — para que a pergunta e aquilo que você precisa olhar para respondê-la cheguem juntos.

Exceção sensata: se o agente está bloqueado e você está olhando a tela, ele pergunta já. Fazer você esperar 45 segundos com o celular na mão para "agrupar" seria a caricatura da ideia.

O formato do bloco: o resultado em cima, as perguntas embaixo, cada uma com a opção recomendada já marcada e um "decida você" sempre disponível. Responder o bloco inteiro é um único botão.

As decisões que ele toma sozinho são visíveis e reversíveis

Nenhuma decisão automática é silenciosa. Ela é mostrada, explicada e desfeita:

"Isso eu decidi: manter o design system atual. Porque você escolheu o mesmo em 3 e 7 de agosto." · Não, me pergunte → reverte, apaga o precedente e volta a perguntar no lugar.

Há dois níveis de autonomia, não três, com nomes que dizem algo: Manual e Inteligente. O Manual sempre pergunta. O Inteligente reutiliza o que você já decidiu diante da mesma pergunta. O nível se muda de dentro do modo, enquanto você olha o que o Cortex acabou de decidir, não três telas adiante.

Uma nota de honestidade sobre como trabalhamos: havia um terceiro nível e ele foi cortado antes de sair, porque, na revisão, fazia exatamente o mesmo que o segundo. Um ajuste que não muda nada é pior que não existir — ainda mais na tela em que se está dizendo ao usuário que isso custa dinheiro.

Quando algo quebra

Um agente que falha não pode ficar dizendo "estou nisso". O cartão dele diz o que foi tentado, com que erro falhou —a mensagem real, não uma categoria genérica—, quanto você já gastou, e oferece três saídas: tentar de novo, passar para outro ou eu faço (esta última abre o chat normal com todo o contexto já carregado).

O mesmo com o orçamento: se a missão não vai chegar ao fim, isso é dito antes de gastar tudo.

O encerramento ele propõe e você confirma

Ao terminar: o que foi feito em duas linhas, o que cada agente tocou, e um aviso âmbar sobre o que foi tocado fora do que ele disse que ia tocar. Você aceita ou descarta por agente: "fique com o do de interface, jogue fora o do de testes", sem revisar diffs à mão.

Sair não cancela nada

Os agentes continuam. Matar trabalho que você já pagou, sem avisar, foi considerado inaceitável desde o primeiro dia. A tira continua visível, pequena, dentro do chat normal, a um toque de distância. E há um botão vermelho de parada total sempre à vista, além de poder parar agentes um a um.

E você pode promover um chat que já tem

No menu de qualquer conversa existente: "Converter em agente". Ele mantém o histórico e o contexto, você dá nome, ferramentas e escopo —com valores deduzidos do que já está lá dentro— e ele passa a receber tarefas do coordenador.

É a porta de entrada barata para o modo: no primeiro dia você já tem agentes com contexto que custou dinheiro acumular, em vez de um catálogo vazio te encarando.

O que há embaixo, sem tecnicismos

Cada agente trabalha no seu próprio espaço isolado. Eles não compartilham estado. Isso não foi capricho de arquitetura: ao implementar, descobriu-se e corrigiu-se uma falha real que já estava em produção com um único chat — o terminal recusava comandos a menos que outro modo tivesse iniciado antes.

Nunca dois agentes escrevendo no mesmo arquivo ao mesmo tempo. A distribuição serializa por escopo de arquivos. E dizemos com igual clareza onde essa proteção acaba: ela cobre os agentes da missão, não impede que você edite aquele arquivo à mão ao mesmo tempo. Nenhuma coordenação evita isso sozinha, e prometer o contrário seria mentira.

O plano que o modelo produz é validado antes de executar qualquer coisa. Um modelo escreve dependências circulares ou inventadas sem pestanejar; descobrir isso no meio da execução é descobrir com o dinheiro já gasto. Se algo do plano é impossível, o modo diz e segue com o resto em vez de travar.

Cinco ferramentas de comunicação entre agentes. Um agente pode consultar quem mais está trabalhando e em quê; o que acabou de terminar na missão e como; o que o usuário já decidiu, para não repetir a pergunta; escalar algo fora do seu escopo; e entregar de forma estruturada o que o próximo precisa saber.

E duas que decidimos deliberadamente não construir — provavelmente o detalhe mais interessante de tudo isto:

1. Um agente não pode encomendar trabalho a outro pelo nome. Seria um buraco de permissões e uma fábrica de laços ao mesmo tempo: se o agente de documentação —somente leitura— pode encomendar trabalho ao de backend, então ele tem de fato as permissões do de backend, e os limites por agente viram decoração. Além disso, dois agentes que conversam entre si podem se revezar até esgotar o orçamento sem ninguém ver. Em vez disso, um agente descreve a necessidade e o coordenador decide o destinatário: um único ponto de controle e de auditoria.
2. Um agente não pode ler a conversa inteira de outro. É caro e é uma superfície de ataque: uma transcrição leva arquivos do projeto dentro, e um arquivo do projeto pode trazer texto escrito para manipular o modelo. São dados resumos de uma linha, e o que chega de outro agente vai marcado como dado, não como instrução.

Tudo passa pela mesma porta de permissões do resto do app. A comunicação entre sessões foi implementada como ferramentas justamente para isso: para não criar um canal paralelo que driblasse os controles.

O dinheiro, à vista

O PocketCode funciona com a sua própria chave de provedor de IA — BYOK. Cada token é você quem paga. Um modo que coloca um coordenador entre você e o trabalho tem a obrigação de mostrar o que essa indireção custa:

• A barra mostra o gasto da missão.
• Cada sessão mostra o seu.
• O gasto do próprio coordenador vai separado e etiquetado, para que se possa julgar se a indireção se paga.
• As estimativas são marcadas com "~". Nunca se inventa um valor em euros.
• Quando o pareamento foi resolvido no celular sem chamar nenhum modelo, mostra 0 tokens.

Há também um limite de 2 frentes de trabalho ao mesmo tempo por padrão, ajustável. É um limite da sua atenção, não técnico: e nenhuma nova frente é aberta enquanto houver decisões sem resposta, para que a pilha não cresça mais rápido do que você a esvazia.

A régua que nós mesmos definimos

Está escrita no documento de projeto antes da primeira linha de interface:

O Cortex é uma indireção: entre você e o trabalho há mais alguém. Só se paga se tirar trabalho de você. A métrica não é quantos agentes aparecem, é quantas vezes o app te interrompe para terminar a mesma tarefa, e quanto custa cada interrupção.

E a condição: se em três tarefas reais as interrupções não caírem em relação ao modo normal, o modo não sai.

As cinco regras da interface:

1. Nunca perguntar duas vezes o que cabe em uma pergunta.
2. Nunca perguntar antes de ter algo para mostrar — a pergunta viaja com o resultado.
3. Toda pergunta chega com uma resposta já marcada: um toque = seguir.
4. Nada para por falta de resposta se houver outro caminho: o agente estaciona aquele ramo e segue por outro.
5. Nenhuma decisão automática é silenciosa: é mostrada, explicada e revertida.

E os antiobjetivos — o que decidimos não fazer:

• Nada de nomes e rostos para os agentes. Eles se identificam pelo que fazem. Dar-lhes personalidade é pedir ao usuário que se apegue a um template.
• Nada de organograma. Não se contrata, não se demite, não se promove.
• A sessão de cada agente não é onde se trabalha. Existe para ler e depurar. Se você acabar morando ali, o modo fracassou.
• Nada de quadro Kanban. O AI Office já tem.
• Zero animações infinitas. Precedente nosso: um painel anterior do app chegou a consumir cerca de 92% de CPU em repouso por exatamente isso.
• Zero setas de voltar. O app navega por gestos; é política do projeto.

Detalhes pequenos que dizem muito

• Marca própria. O Cortex tinha no início o mesmo ícone do Swarmcode. Desenhou-se um próprio: dois modos diferentes com o mesmo símbolo são um modo com dois nomes.
• Modelo próprio. Cada agente escolhia o seu modelo; o único que não escolhia era o coordenador. Agora escolhe: o trabalho dele não se parece com o de um agente —não escreve código, lê uma encomenda e decide quem faz o quê—, então aceita um modelo mais barato… ou o melhor, se preferir. Por padrão herda o do chat, então quem não mexer em nada nem nota que ele existe.
• Conversa própria, uma por projeto. Não uma por missão: o que ela acumula é o índice do seu trabalho, e esse índice não acaba quando acaba uma missão.
• Interface em cinco idiomas desde o primeiro dia: cerca de 250 novos textos.
• Tudo isso em um celular. Não há servidor por trás coordenando: a distribuição, a memória de decisões e o isolamento entre agentes rodam no dispositivo.

Em que ponto está, com honestidade

Construído, compilado, mais de mil testes automatizados no verde em dez módulos — executados com os caches desativados e os resultados anteriores apagados, porque um sistema de build que reutiliza resultados velhos diz "está tudo bem" sem ter executado nada. A migração do banco de dados e a exclusão em cascata foram verificadas em um celular real com testes instrumentados, não deduzidas do código. E o modo passou por uma revisão de lacunas deliberadamente adversarial antes de ser dado como pronto.

O que não vamos afirmar: ainda não está testado em uso diário real. Esta é a primeira versão de um modo que desenhamos há meses, não a forma como já trabalhamos. E aqui não há data de lançamento de propósito: como no alfa, preferimos entregar a prometer.

Duas coisas que vale dizer com clareza:

• O Cortex é um recurso pago, com um teste de 3 missões completas. Elas são consumidas ao terminar: uma missão que falha no meio não custa um teste.
• Requer um provedor de IA configurado com a sua própria chave. Sem chave, sem modo. É coerente com todo o chat do app, mas precisa ser dito.

---

A pergunta interessante em um sistema multiagente não é quantos agentes você consegue lançar. É quem está mantendo o índice — e se o que você colocou no meio está pagando o próprio salário.

O PocketCode está a caminho do Google Play. Faça o pré-cadastro para saber do lançamento antes de todo mundo, ou dê uma olhada no roadmap.