Agentes de Intenção: O Fim da Programação?

Quem está prestando atenção pode sentir: o show de fogos de artifício está desacelerando. O GPT-4, Claude 3 Opus e Gemini 1.5 são inegavelmente fortes, mas não representam o mesmo salto impressionante que o GPT-3 fez sobre o GPT-2. Os benchmarks continuam subindo — MMLU, HumanEval, GSM8K — mas o fator “uau” do poder bruto dos LLMs não dobra mais a cada seis meses.

Essa desaceleração não é imaginária; é economia. Treinar um modelo de ponta agora custa centenas de milhões de dólares em computação, curadoria de dados e engenharia. Cada ponto percentual extra em um ranking como MMLU ou Codeforces demanda exponencialmente mais GPUs, mais tokens e mais feedback humano.

Os retornos decrescentes atingem todos os lugares. Janelas de contexto maiores—200K, 1M tokens—existem, mas o raciocínio eficaz sobre esse contexto ainda falha de maneiras frágeis. Modelos de código acertam na geração de código padrão e em padrões comuns, mas hallucinam APIs ou interpretam mal situações limites que qualquer engenheiro de nível médio perceberia em uma revisão de código.

Assim, a fronteira mudou. Cole Medin acerta em cheio em seu vídeo: o “poder bruto dos LLMs simplesmente não está mais explodindo”, mas a camada ao redor deles está. A orquestração de ferramentas, sistemas de memória e coordenação entre múltiplos agentes estão proporcionando mudanças mais significativas do que mais um 0,3 em um benchmark.

Pense nisso como uma transição de CPUs mais rápidas para sistemas operacionais melhores. Agentes, roteadores de contexto e modelos de mundo se baseiam no GPT-4 ou Claude 3 e extraem mais confiabilidade de uma inteligência subjacente aproximadamente igual. O hardware da mente atinge um platô; o conjunto de software ao seu redor começa a ser mais relevante.

Isso reformula este momento não como um teto, mas como um ponto de inflexão. Em vez de rezar para que o GPT-5 seja 10 vezes mais inteligente, as equipes estão construindo estruturas de agentes que gerenciam ferramentas, tentativas e fluxos de trabalho de longa duração, para que os modelos de hoje se comportem como colegas de trabalho confiáveis. O foco da inovação muda de pesos de modelo para design de sistema.

Chame isso de era pós-referencial. Ganhos marginais em modelos ainda são importantes, mas as verdadeiras inovações virão da construção da estrutura—memória, planejamento, verificação—ao redor dos LLMs. A ação se desloca dos treinamentos em laboratório para o código de harness do engenheiro.

Chamadas de modelos brutos estão começando a parecer silício nu: impressionantes no papel, frágeis na prática. A afirmação central de Cole Medin é direta: a verdadeira ação se deslocou para a "camada sobre os LLMs" — a lógica de orquestração que transforma um engenho de autocomplete inteligente em algo em que você pode confiar para trabalhos reais.

Essa camada agora tem um nome: o harness do agente. Pense nisso como um sistema operacional para modelos, gerenciando o fluxo de controle, a memória e o uso de ferramentas para que um LLM possa sobreviver fora de uma demonstração e dentro de um SLA de produção.

Uma chamada bruta de LLM se comporta como uma solicitação de API sem estado. Você envia um prompt, espera que o modelo tenha entendido sua intenção e recebe um bloco de texto que pode ignorar ferramentas, esquecer etapas anteriores ou alucinar APIs que nunca existiram.

Coloque o mesmo modelo em um arnês e o comportamento muda. O arnês rastreia o estado ao longo de dezenas ou centenas de etapas, mantém a memória de trabalho e impõe políticas sobre quais ferramentas o modelo pode chamar, quando e com quais argumentos.

Os modernos harnesses combinam várias capacidades que antes existiam em scripts dispersos e prompts ad hoc: - Armazenamentos de memória de longo e curto prazo - Roteamento de ferramentas e tentativas de correção cientes de erros - Coordenação e agendamento de subagentes - Guardrails, validação e observabilidade

Projetos como o sistema interno da Anthropic, o DeepAgent da LangChain e o Linear Agent Harness de Cole Medin mostram o padrão se cristalizando. Ao invés de uma única conclusão de chat, você obtém gráficos de agentes, ferramentas e estados que podem operar por horas sem a supervisão de um humano.

É aqui que a alavancagem da engenharia humana agora reside. Você não pode ajustar os pesos do GPT-4.5, mas pode decidir quantos subagentes criar, como eles compartilham janelas de contexto, como decompõem tarefas e como se recuperam de chamadas de ferramentas malsucedidas.

Esperar pelo “GPT-6 mas 10x” perde o foco. O próximo avanço de 10x virá de um design de harness melhor: ciclos de planejamento mais inteligentes, modelos de mundo mais ricos, e um feedback mais preciso dos registros de volta para os prompts e políticas.

Equipes de software que tratam o modelo como uma mercadoria e o harness como o produto irão capturar o valor. Todos os outros estarão apenas chamando uma API e esperando o melhor.

O agente pode parecer algo vago, mas a Anthropic e a LangChain definem algo muito concreto: uma camada de controle estruturada que chama repetidamente um LLM, rastreia o estado e orquestra ferramentas até que uma tarefa seja concluída. A especificação do harness da Anthropic descreve um controlador que administra o loop, tratamento de erros, memória e roteamento de ferramentas, enquanto o modelo apenas prevê o próximo token. A documentação do DeepAgent da LangChain avança ainda mais, enquadrando o harness como uma política programável que decide o que o agente faz a cada passo.

Mais do que um loop while glorificado, uma harness moderna funciona como uma máquina de estados. Cada etapa transita entre estados como “planejamento”, “chamada_de_ferramenta_pendente”, “aguardando_humano” ou “concluído”, com regras explícitas sobre o que é permitido em cada estado. Essa estrutura torna o comportamento reproduzível e depurável, ao invés de depender de sensações e esperanças.

As responsabilidades principais se agrupam em quatro categorias que aparecem em toda a Anthropic, LangChain e na Linear Agent Harness de Cole Medin. Um harness deve gerenciar a memória persistente, governar ferramentas, coordenar múltiplos trabalhadores e supervisionar fluxos de longa duração. Remova qualquer um desses elementos e os agentes rapidamente regridem a chatbots de uma única interação.

A gestão da memória agora se assemelha a um problema de banco de dados em miniatura. Os sistemas de gerenciamento mantêm áreas de trabalho de curto prazo, armazenamentos vetoriais para recuperação semântica e registros de longo prazo, decidindo o que resumir, o que descartar e o que rehidratar em janelas de contexto limitadas a 200k–1M tokens. Eles também controlam dados sensíveis, definindo quais subagentes podem ver o quê, uma exigência para qualquer implantação empresarial.

O controle de ferramentas transforma o harness em um motor de políticas. Ele decide: - Quais ferramentas o LLM pode chamar - Como os argumentos são validados e sanitizados - Como repetir, debilitar ou paralelizar chamadas

Essa camada de política previne desastres de injeção de comando como "baixar banco de dados prod" e impede que APIs instáveis atrapalhem fluxos de trabalho após um erro 500.

A coordenação de sub-agentes leva os harnesses para o território da orquestração. Um sistema de codificação pode gerar agentes separados para planejamento, implementação, teste e refatoração, cada um com ferramentas e memória específicas. O harness atribui tarefas, mescla resultados e resolve conflitos quando os agentes discordam, semelhante a um sistema de compilação que arbitra as saídas do compilador e do linter.

Visto de 10.000 pés, o LLM se parece com um núcleo, enquanto o harness se comporta como um shell de sistema operacional mais runtime. Ele fornece agendamento, I/O, permissões e registro em torno de um núcleo muito inteligente, mas muito amnésico. O próprio artigo da Anthropic, Harnesses eficazes para agentes de longa duração - Anthropic, efetivamente lê-se como um documento de design para esse shell.

O desenvolvimento inicial de IA parecia enganosamente poderoso: escreva um prompt inteligente, talvez adicione um pipeline básico de RAG, e veja o modelo gerar código ou documentação. Isso funcionou para tarefas únicas—esboçar uma função, resumir um PDF, responder uma pergunta de um pequeno armazenamento vetorial. No momento em que você ultrapassava isso, tudo desmoronava.

Sistemas baseados apenas em prompts se comportam como estagiários com amnésia. Peça a um LLM para refatorar um monólito de 200.000 linhas com um único prompt e você obtém edições parciais, arquivos alucinatórios e importações corrompidas. Mesmo com recuperação, o RAG ingênuo apenas insere fragmentos “relevantes” no contexto; ele não rastreia o estado, não verifica resultados e não lembra do que já foi executado.

Trabalhos complexos e em várias etapas expõem essas falhas rapidamente. Tarefas de longa duração — migrações, refatorações de múltiplos serviços, runbooks de incidentes — precisam de lógica de ramificação, retrocesso e consciência de restrições externas, como falhas de teste ou limites de taxa de API. Mensagens estáticas não conseguem se adaptar quando um conjunto de testes expira, há um conflito de dependências ou uma ferramenta retorna JSON malformado.

O agente moderno utiliza um ataque que ataca diretamente essa fragilidade. Em vez de um único comando, você obtém um ciclo de controle que pode planejar, agir, observar e revisar ao longo de dezenas ou centenas de etapas. O sistema controla o gráfico de execução, não o modelo: ele decide quando chamar ferramentas, quando replanejar e quando abortar.

As tentativas deixam de ser uma reflexão tardia. Ferramentas como o harness de codificação da Anthropic ou o DeepAgent da LangChain envolvem cada chamada de ferramenta com um manuseio de erro estruturado: tentativas automáticas em falhas de rede, validação de esquema em saídas de ferramentas e reintroduções direcionadas quando o modelo se desvia das especificações. Elas registram cada passo, permitindo que o agente inspecione seu próprio histórico e corrija o rumo.

O planejamento dinâmico se torna um recurso de primeira classe. Em vez de uma sequência fixa, o sistema atualiza a lista de tarefas com base no feedback da ferramenta: - Gerar um plano - Executar uma ferramenta - Comparar o esperado com o real - Inserir, excluir ou reordernar etapas

Considere a refatoração de uma grande base de código novamente. Um único comando pode tentar reescrever tudo de uma vez, ultrapassar os limites de contexto e entregar código que não compila. Um agente orientado por harness pode escanear o repositório, dividir arquivos, refatorar módulo por módulo, executar testes após cada lote, detectar falhas, reverter alterações específicas e reparar iterativamente até que o conjunto de testes seja aprovado.

Os agentes de produção parecem menos com prompts inteligentes e mais com micro sistemas operacionais. O harness DeepAgent da LangChain, as estruturas internas da Anthropic e o harness Linear de Cole Medin convergem para a mesma arquitetura: um ciclo fechado envolvendo quatro componentes principais que mantêm um modelo de linguagem grande focado em um objetivo, em vez de divagar por sentimentos.

Na base está o Gerenciador de Estado. Este módulo rastreia o objetivo atual do agente, subobjetivos intermediários, histórico de etapas e metadados de execução: quais ferramentas foram utilizadas, o que retornaram e se falharam. No DeepAgent, isso frequentemente existe como um objeto de estado estruturado que flui através de cada chamada, proporcionando ao modelo uma visão canônica de "onde estamos" e "o que acabou de acontecer."

Uma boa gestão de estado vai além do registro. Ela impõe esquemas para cada etapa, persiste pontos de verificação para que tarefas de longa duração possam ser retomadas após uma falha e registra restrições como limites de tempo ou orçamentos de tokens. Em vez de uma conversa livre, o agente opera dentro de um fluxo de trabalho tipificado que pode ser auditado, reproduzido e testado.

Paralelamente ao estado, o Controlador de Ferramentas medeia cada efeito colateral. Ferramentas nunca permitem que o modelo chame APIs brutas ou toque diretamente no sistema de arquivos; elas expõem um conjunto de ferramentas rigorosamente selecionadas com contratos estritos de entrada e saída. No LangChain, as ferramentas declaram esquemas JSON e mecanismos de segurança, permitindo que o controlador valide argumentos, controle solicitações e bloqueie ações claramente perigosas.

Um controlador robusto também gerencia: - Autenticação e isolamento de segredos - Limitação de taxa e retrocesso entre vários provedores - Execução em sandbox para ferramentas de arquivo, shell ou código

A memória reside em seu próprio módulo, conectando os limites de contexto do LLM de 200K a 1M de tokens com cargas de trabalho do mundo real que abrangem dias. A memória de curto prazo geralmente se parece com um bloquinho: um resumo em andamento dos últimos N passos, comprimido pelo próprio modelo para permanecer dentro do orçamento. A memória de longo prazo vive em bancos de dados vetoriais como Pinecone, Weaviate ou pgvector, indexados por embeddings de modelos como text-embedding-3-large.

Os harnesses inteligentes distinguem entre memória de tarefa efêmera, memória de projeto durável e conhecimento organizacional global. Eles decidem o que resumir, o que incorporar e o que descartar, em vez de tudo ser reintroduzido no prompt.

Mantendo tudo isso unido, o Despachante/Coordenador executa o loop central. Ele fornece ao LLM o estado atual e a memória, analisa a "intenção" do modelo (chamar uma ferramenta, criar uma subtarefa ou finalizar a saída) e direciona o controle para o componente certo. Cada iteração atualiza o estado, anexa memória e apressa as restrições, transformando um modelo estocástico em um sistema previsível.

A codificação por vibe pode parecer uma piada até você perceber que descreve o que todo desenvolvedor realmente deseja: declarar um resultado, evitar o boilerplate e entregar. Nesse contexto, codificação por vibe significa descrever a intenção no nível de "criar um bot no Slack que triage incidentes" e deixar o sistema descobrir APIs, projetar modelos de dados e escrever testes sem que você precise monitorar cada função.

Por anos, isso foi uma fantasia, pois LLMs brutos se comportam como estagiários talentosos, mas pouco confiáveis. Eles fabricam APIs, ignoram casos extremos e perdem o fio de planos complexos após uma dúzia de interações. Mesmo com o GPT-4 ou Claude 3.5, solicitar um sistema não trivial—digamos, um SaaS completo com CRUD, autenticação, faturamento e análises—ainda resulta em código que compila, mas que falha silenciosamente sob tráfego real e dados reais.

O agente aproveita as mudanças para moldar esse risco. Eles transformam a “vibe” em um objetivo de alto nível e forçam o modelo a funcionar dentro de uma estrutura de ferramentas, memória e restrições explícitas. Em vez de “escrever um backend,” você pede ao harness para “fornecer um backend pronto para produção,” e ele orquestra subtarefas: design de esquema, migrações, testes de integração, configurações de implantação.

Os modernos sistemas de controle, como a estrutura interna da Anthropic ou o DeepAgent da LangChain, não confiam em uma única chamada de LLM. Eles impõem ciclos de planejar → agir → verificar, registram cada passo e encaminham falhas de volta através de depuradores ou revisão humana. A LangChain documenta isso explicitamente em suas capacidades do sistema de controle de agentes - Documentos da LangChain, onde os agentes recebem metas estruturadas, escolhem ferramentas e mantêm um estado de múltiplas etapas.

Assim, a codificação por vibe se torna "meio que" viável, exatamente da forma como Cole Medin argumenta. Você vibra na fronteira do sistema—“migre nosso monólito para uma arquitetura orientada a serviços até o terceiro trimestre, mantenha a latência abaixo de 150 ms, reutilize a autenticação existente”—e o sistema decompoe isso em centenas de ações concretas. O LLM não faz mais associações livres; ele opera dentro de um fluxo de trabalho governado e testável.

Crucialmente, você não está apenas interagindo com uma caixa de bate-papo de LLM sem roupas. Você está emitindo diretrizes de alto nível para um sistema robusto que você projetou: esquemas de ferramentas, barreiras de segurança, ganchos de observabilidade, estratégias de reversão. A criatividade se eleva a um novo patamar—de escrever loops para projetar o suporte que faz da programação vibe algo em que você realmente pode apostar em um roteiro.

Os programadores estão sendo promovidos silenciosamente a arquitetos de sistemas de IA. Em vez de trabalhar arduamente com controladores, serviços e mapeadores de banco de dados, eles orquestram redes de modelos, ferramentas e fluxos de trabalho que se comportam mais como equipes do que como scripts. A função muda de “escrever uma funcionalidade” para “projetar como um sistema inteligente pensa e age.”

Cole Medin captura o cerne da questão de forma direta: “estamos projetando o sistema, projetando a estrutura, mas não vamos estar escrevendo a maior parte do código em um futuro muito próximo.” Essa frase parece hiperbólica até você ver um agente como DeepSeek, Claude ou GPT realizando chamadas REST, migrações e testes a partir de um parágrafo de intenção. O humano ainda define a direção; o agente cuida da estrutura.

Os desenvolvedores do novo dia definem metas de agentes com a precisão de especificações de produto. Em vez de "construir uma página de cobrança", eles formular metas como "manter as faturas do Stripe em sincronia com nosso livro contábil interno, reconciliar falhas a cada hora e escalar anomalias acima de $5.000." O sistema traduz isso em ferramentas, subagentes e diretrizes.

Ferramentas se tornam uma habilidade de primeira classe. Arquitetos escolhem ou constroem funções para: - Acessar APIs e serviços internos - Consultar armazenamentos vetoriais e armazéns SQL - Acionar mudanças de CI/CD e infraestrutura

Cada ferramenta precisa de esquemas rigorosos, limites de autenticação e orçamentos de latência. A qualidade dessas ferramentas determina quão competente o agente se sente.

O Harness Logic substitui o código de orquestração escrito à mão. Os desenvolvedores projetam ciclos de planejamento, políticas de reexibição de erros, estratégias de memória e portas de aprovação. Um “arquivo de fluxo de trabalho” pode declarar como um agente decompõe tarefas, quando pode gerar subagentes e o que é registrado para auditoria. Parece menos com Java e mais com Terraform para cognição.

A depuração se transforma em uma análise forense de rastros de raciocínio. Em vez de percorrer os quadros de pilha, você inspeciona cadeias de pensamento, chamadas de ferramentas e janelas de contexto. Você ajusta os prompts, modifica os contratos das ferramentas ou reconfigura o planejador, e então executa novamente o cenário.

Longe de eliminar programadores, essa mudança os transforma de pedreiros em arquitetos. Os problemas difíceis sobem de nível: de escrever loops a projetar sistemas que podem escrever os seus próprios—de maneira confiável, segura e em grande escala.

Agentes deixam de ser abstratos no momento em que você os direciona para um problema entediante e caro. A própria equipe de engenharia da Anthropic usou uma ferramenta para realizar análises de dados de várias horas em um enorme conjunto de dados interno, com agentes orquestrando consultas SQL, resumindo resultados e iterando em hipóteses sem a supervisão de um humano. O relatório deles descreve fluxos de trabalho de longa duração que sobreviveram a erros de ferramentas, contratempos de API e mudanças nas instruções, enquanto ainda convergiam para um relatório utilizável.

Esse exemplo da Anthropic se assemelha menos a "conversar com um bot" e mais a um analista de dados autônomo. O sistema monitora o estado em várias chamadas de ferramentas, registra saídas intermediárias e decide quando parar, não apenas o que dizer a seguir. Você obtém algo mais próximo de um serviço contínuo do que de uma conclusão isolada.

O Linear-Copilot-Harness de Cole Medin, de código aberto, mostra como isso funciona dentro de um fluxo de trabalho real de SaaS. Ele conecta um LLM à API do Linear para criar, classificar e atualizar tickets enquanto gerencia o contexto do histórico de problemas, convenções da equipe e marcos do projeto. Em vez de um comando frágil como "escrever um ticket", o harness gerencia ferramentas, memória e restrições para que o agente se comporte como um gerente de projeto júnior integrado ao Linear.

O harness da Medin baseia-se em padrões como: - Roteamento de ferramentas com base no tipo de tarefa - Memória persistente associada a questões lineares e usuários - Planos de múltiplos passos que podem ser reorganizados quando as ferramentas falham

Esses mesmos padrões se traduzem de forma clara em outros agentes geradores de lucro. Sistemas autônomos de pesquisa financeira podem analisar relatórios, chamadas de resultados e dados de mercado, e então manter uma tese atualizada sobre uma empresa ou setor. Um sistema de controle coordena a busca de documentos, modelagem em planilhas e resumos de risco, enquanto impõe rígidos limites de ferramentas para qualquer coisa que envolva capital real.

Agentes de teste de QA automatizados podem gerenciar suítes de regressão de forma completa. Eles geram testes, acionam pipelines de CI, interpretam falhas, registram tickets e reexecutam verificações específicas após as correções serem implementadas. O sistema mantém um mapa de longa duração de cobertura de testes, flutuações históricas e responsabilidade por componentes, permitindo que o agente melhore ao longo das semanas, em vez de reiniciar a cada execução.

As equipes de marketing já estão experimentando agentes de campanha autogerenciáveis. Um sistema pode orquestrar a geração de texto, testes criativos A/B, realocação de orçamentos e consultas analíticas em Google Ads, Meta e plataformas de e-mail. Plataformas de nível empresarial, como o OutSystems Agent Workbench, estão se apressando para transformar isso em produtos, empacotando padrões de sistema em “receitas de agente” que podem ser integradas diretamente nas pilhas existentes.

Pavel Panchekha oferece o modelo mental mais claro para tudo isso: Modelos de Linguagem de Grande Escala (LLMs) são núcleos, e os mecanismos de controle são conchas. Pense em Linux mais bash, não em "agente mágico". O núcleo expõe o poder bruto; a concha decide como humanos e programas realmente o utilizam.

Um kernel de sistema operacional agenda processos, gerencia a memória e expõe chamadas de sistema. Um shell como bash ou zsh transforma isso em `ls`, pipes, scripts e automação. Troque Claude ou GPT pelo kernel, e seu harness se torna o shell: ele interpreta a intenção do usuário, sequencia as chamadas de ferramentas e mantém trabalhos de longa duração ativos.

Leia Agentes de Harness são Apenas Conchas - Pavel Panchekha e a analogia se torna clara. O “núcleo” LLM pode: - Gerar e transformar texto - Chamar ferramentas via chamadas de função estruturadas - Manter o estado conversacional de curto prazo

O “invólucro” do harness envolve isso com: - Controle de processos para tarefas que duram minutos, horas ou dias - Orquestração de ferramentas através de APIs, bancos de dados e bases de código - Persistência, registro e recuperação quando as coisas falham

Visto dessa forma, o DeepAgent da LangChain, os exemplos de harness da Anthropic e o harness do agente Linear de Cole Medin parecem menos com IA exótica e mais com engenharia de sistemas operacional familiar. Eles implementam loops de agendamento, tentativas, retrocesso e máquinas de estado—apenas direcionados a chamadas de LLM em vez de chamadas de sistema. A mágica muda de "engenharia de prompt" para projetar um runtime robusto.

Este modelo também esclarece por que os ganhos de LLM bruto parecem incrementais, enquanto os ganhos de harness parecem multiplicativos. Um núcleo melhor é importante, mas uma concha melhor muda a forma como cada usuário e cada processo interagem com esse núcleo. O Bash fez mais pela usabilidade do Unix do que qualquer atualização de CPU isolada.

Portanto, o próximo passo lógico para os desenvolvedores é óbvio: parar de tratar os agentes como aplicativos monolíticos e começar a tratar as fiações como ambientes operacionais. Não estamos mais apenas chamando núcleos; estamos construindo invólucros para uma nova classe inteiramente nova de software.

Os harnesses de agentes estão saindo dos blogs de pesquisa para os currículos. Até 2026, ser "bom com IA" significará que você pode projetar, depurar e enviar harnesses que mantêm os LLMs focados por horas, e não apenas que você pode escrever um prompt inteligente. Trate a construção de harnesses como aprender React em 2015 ou Kubernetes em 2018: opcional a princípio, depois obrigatória para um trabalho sério.

Comece com um sistema concreto: um assistente de codificação que possa gerenciar um repositório por 30 a 60 minutos. Conecte chamadas de ferramentas para git, entrada/saída de arquivos e testes, e depois adicione proteções: acompanhamento de estado, políticas de repetição e critérios de sucesso explícitos. Meça o sucesso com números concretos: taxa de correção de bugs, tempo até o PR e com que frequência humanos precisam resgatar o agente.

Seu livro didático principal são os documentos do LangChain DeepAgent. Estude como ele modela o estado do agente, o roteamento de ferramentas e planos de várias etapas, e então adapte esse padrão para sua própria pilha, mesmo que você nunca importe o LangChain. Trate seu design como você trataria a leitura do código-fonte de um bom escalonador de sistema operacional: uma implementação de referência do que “robusto” significa.

O blog de engenharia da Anthropic é outro que você deve ler. O seu sistema para a análise de dados de longa duração mostra como gerenciar memória, registro de logs e modos de falha quando os trabalhos duram horas. Preste atenção em como eles dividem o trabalho, marcam o progresso e limitam o alcance de um chamador de modelo ruim.

O GitHub já está cheio de modelos. Estude harnesses abertos como o Linear agent harness de Cole Medin e os exemplos da Anthropic, e então: - Faça um fork e substitua pelas suas próprias ferramentas - Adicione telemetria e rastreamento de custos - Fortaleça-o para uma carga de trabalho real no seu trabalho ou projeto paralelo

O trabalho futuro de alto impacto em IA pertencerá às pessoas que conseguirem envolver modelos brutos em sistemas confiáveis. Se Cole Medin estiver certo e delegarmos 99% da programação a agentes, a alavanca ficará com quem projetar os suportes nos quais esses agentes operam. Você pode ser a pessoa que constrói as cascas em torno dos núcleos do amanhã.

O que é um harness de agente de IA?

Um arnês de agente é uma estrutura organizada que gerencia a memória, as ferramentas e o estado de um agente de IA para garantir que ele possa executar com confiabilidade tarefas complexas e de longa duração, assim como um shell gerencia um kernel em um sistema operacional.

Como um cinto de segurança é diferente da engenharia de prompts?

Enquanto a engenharia de prompts se concentra em criar a entrada inicial perfeita, um harness constrói todo um sistema operacional em torno do LLM para controlar seu fluxo de execução, gerenciar ferramentas e lidar com erros ao longo do tempo.

Os agentes de harness substituirão os desenvolvedores de software?

Eles estão prontos para mudar o papel dos desenvolvedores de escrever código linha por linha para projetar e engenheirar os sistemas (harnesses) que orientam os agentes de IA a escrever o código, elevando-os à posição de arquitetos de sistemas.

Estão 'vibe coding' e harnesses de agentes relacionados?

Sim. 'Codificação de vibes'—descrevendo um resultado desejado em linguagem natural—torna-se mais viável com os harnesses, pois eles oferecem a confiabilidade necessária para traduzir 'vibes' de alto nível em uma execução funcional de código em múltiplas etapas.