No desenvolvimento de software tradicional, o ciclo de vida de desenvolvimento de software (SDLC) fornece uma abordagem estruturada e em fases para criar aplicativos. Ela estabelece a qualidade, reduz o risco e fornece um roteiro claro da ideia à versão. O Ciclo de vida de desenvolvimento do agente (ADLC) é uma metodologia semelhante personalizada de modo distinto para lidar com as complexidades exclusivas da criação de agentes autônomos.

Os agentes não são aplicativos passivos; são sistemas que justificam, agem e aprendem em ambientes de execução dinâmica. Seu comportamento não determinista torna a QA tradicional insuficiente. O ciclo de vida do desenvolvimento do agente (ADLC), promovido por plataformas como Agentforce, lida com isso em cinco fases: Ideia e design, Desenvolvimento (o "loop interno"), Teste e validação, Implantação e Monitoramento e ajuste contínuos (o "loop externo").

Este documento serve como um guia abrangente para desenvolvedores e arquitetos empresariais que já estão familiarizados com as complexidades do ciclo de vida de desenvolvimento de software (SDLC) e estão procurando expandir seu conhecimento em sistemas baseados em agente. Nosso objetivo principal é facilitar uma rápida compreensão do Ciclo de vida de desenvolvimento do agente (ADLC) destacando suas principais distinções das metodologias SDLC tradicionais e fornecendo uma estrutura estruturada para conceituar todo o processo de criar, implementar e gerenciar agentes inteligentes.

O documento é organizado em três capítulos distintos, cada um destinado a desenvolver progressivamente seus Knowledge e habilidades práticas:

• Capítulo 1: O ADLC Framework. Este capítulo apresenta o Ciclo de vida de desenvolvimento do agente (ADLC), detalhando sua discrepância do SDLC devido aos desafios exclusivos de desenvolver agentes autônomos. Ela estabelece uma estrutura para projetar, desenvolver, testar e implementar agentes.
• Capítulo 2: A Plataforma Agentforce. Este capítulo explora Agentforce, uma plataforma unificada que simplifica e acelera todo o ciclo de vida do desenvolvimento do agente. A Agentforce oferece ferramentas para design de agente, processamento de dados, treinamento de modelo, implantação e monitoramento contínuo, simplificando tarefas complexas e melhorando a eficiência.
• CAPÍTULO 3: Implementação de pro-código. Este guia usa as ferramentas de pro-código da Agentforce para fornecer instruções práticas, passo a passo e exemplos reais para o desenvolvimento de agentes. Ele abrange todo o ciclo de vida de desenvolvimento do agente, da criação de protótipos e engenharia de recursos à implantação de modelo, ajuste de desempenho e manutenção, equipando os desenvolvedores com as habilidades para criar agentes prontos para produção.

Este documento visa equipá-lo com o Knowledge teórico e prático das ferramentas de pro-código da Agentforce. Você aprenderá a criar, implantar e monitorar agentes de maneira eficiente, segura e confiável, obtendo uma compreensão abrangente do ADLC e maximizando o potencial da Agentforce no desenvolvimento inteligente de agentes.

A natureza não determinista dos agentes de IA requer uma estrutura de desenvolvimento especializada. Este capítulo descreve essa estrutura apresentando o Ciclo de vida de desenvolvimento do agente (ADLC). Este capítulo apresenta uma visão geral abrangente das cinco fases centrais do ADLC, da Ideia e design iniciais ao Monitoramento e ajuste contínuos. Este capítulo estabelece o Knowledge básico necessário para criar agentes robustos e confiáveis.

Esta seção mapeia os conceitos de SDLC para as cinco fases do ADLC.

Esta é a fase fundamental em que o objetivo estratégico e os limites operacionais de um agente são definidos. Uma fase de design bem estruturada é a etapa mais crítica para o sucesso, pois ela traduz uma necessidade comercial em um projeto técnico. O processo de design garante que o agente seja não apenas funcional, mas também responsável e alinhado às expectativas do usuário. É onde o "o que" e o "por quê" são estabelecidos antes de qualquer código ser escrito.

1. Definir metas e capacidades agentes: Primeiro, você deve articular claramente o objetivo principal do agente e as tarefas específicas e mensuráveis que ele realizará. Isso envolve definir seu papel (por exemplo, "assistente de atendimento ao cliente"), suas funções principais (por exemplo, "agendar compromissos", "responder a perguntas do produto") e as métricas de sucesso para cada um.
2. Estabelecer Persona e Guardrails Éticos: Essa etapa envolve projetar a personalidade do agente e definir seus limites éticos para garantir que seja confiável e segura. Ele estabelece o tom do agente (por exemplo, "formal", "amigável") e implementa regras rígidas para evitar respostas prejudiciais, com viés ou impróprias.
3. Contexto do mapa e compreensão: Você deve determinar que informações o agente precisa entender e lembrar para ser eficaz. Isso inclui definir o escopo de sua base de Knowledge e sua memória conversacional, o que lhe permite ter conversas coerentes e de vários turnos.
4. Identificar ferramentas e integrações do sistema: Isso envolve o inventário de sistemas externos, APIs e origens de dados com as quais o agente deve se conectar para executar tarefas. Cada ferramenta (por exemplo, uma API de agendamento, um banco de dados de clientes) é identificada e sua função é mapeada para uma funcionalidade específica do agente.
5. Plano para Escalada Humana no Loop: É essencial definir as condições sob as quais um agente é escalado para um humano. Isso envolve revisar possíveis pontos de falha e "términos inativos" conversacionais para determinar quando um agente deve ser escalado para um operador humano. O design deve descrever como essa transferência será realizada para garantir que o contexto suficiente seja transferido para que possa ser consumido rapidamente para garantir uma experiência do cliente contínua.

Esta é a fase prática de construção em que o projeto de design é transformado em um agente funcional. Os desenvolvedores criam o agente, o conectam a suas ferramentas e o capacitam com os dados de que ele precisa para realizar suas tarefas. Esse "loop interno" iterativo de criação e refinamento é onde o agente realmente ganha vida.

1. Configurar a lógica e a tomada de decisão do agente: Essa etapa envolve moldar o raciocínio do agente conectando sua estrutura de tomada de decisão ao contexto, às ferramentas e às fontes de dados. O papel do desenvolvedor é definir o comportamento do agente criando APIs ou reutilizando APIs existentes, configurando proteções operacionais e especificando como o agente seleciona e usa ferramentas disponíveis para concluir tarefas complexas de várias etapas.
2. Avisos de engenheiro e modelos de ajuste fino: A personalidade, as instruções e as restrições do agente são codificadas por meio da engenharia de instruções meticulosa. Esse processo envolve criar o aviso mestre que orienta o Modelo de idioma grande (LLM) e, para casos de uso mais avançados, ajustar o modelo em dados específicos do domínio para melhorar seu desempenho.
3. Integrar e proteger ferramentas de IA: As funções e as APIs identificadas durante a fase de design são conectadas ao agente. Usando um SDK, os desenvolvedores quebram funções existentes ou criam novas, tornando-as seguramente invocáveis pelo agente e garantindo que tenham a autenticação e o tratamento de erros adequados.
4. Build Data e pipelines RAG: Para capacitar o agente com o Knowledge externo, os desenvolvedores criam os pipelines de dados para a Geração ampliada por recuperação (RAG). Isso envolve a conexão e a indexação de dados de fontes como repositórios vetoriais, bancos de dados relacionais, bancos de dados de gráfico ou documentos internos, tornando essas informações acessíveis ao agente para fornecer respostas precisas e sensíveis ao contexto.

Testar os agentes de IA introduz uma mudança de paradigma da validação determinística de software tradicional. Embora um aplicativo convencional seja testado quanto à correção (uma entrada específica deve produzir uma única saída esperada), a natureza não determinista de um agente requer uma abordagem mais sofisticada. A meta não é validar uma única resposta certa, mas garantir que o comportamento do agente esteja alinhado à finalidade pretendida, seja robusto contra entradas inesperadas e permaneça confiável em um espectro de resultados aceitáveis.

1. Teste de unidade: Essa camada foca os componentes determinísticos não de IA do agente. Ele envolve testes de unidade tradicionais para validar se cada ferramenta e função individuais funcionam corretamente em isolamento, garantindo uma base confiável antes da aplicação do complexo raciocínio do agente.
2. Teste completo (E2E): Esse estágio avalia a capacidade do agente de atingir metas em cenários realistas, o que é essencial devido à sua natureza não determinista. Em vez de verificar uma saída exata, esses testes completos verificam se o agente conclui as tarefas com sucesso e se seu desempenho não diminui conforme as alterações são feitas.
3. Teste de rivalidade e robustez: Essa é a prática de tentar interromper intencionalmente o agente para descobrir proativamente suas fraquezas. Os testadores usam solicitações ambíguas, avisos mal-intencionados e outros casos de extremidade para expor vulnerabilidades e garantir que o agente permaneça resiliente e seguro sob pressão.
4. Avaliação humana no ciclo (HITL): Como os testes automatizados não podem medir qualidades com nuances, como tom ou fluxo conversacional, esse estágio depende de feedback humano. Os testadores interagem com o agente para pontuar suas respostas quanto à utilidade e à experiência geral do usuário, fornecendo dados essenciais para ajustar seu comportamento.
5. Teste de desempenho e escala: Esta é uma etapa crítica para evitar gargalos de desempenho antes que afetem os usuários. Esse processo simula cenários de pico de uso realistas para garantir que agentes e aplicativos possam lidar com grandes volumes de maneira tranquila e previsível. Ela valida se a solução não está apenas correta, mas também escalonável.

A implantação de um agente de IA é um processo gerenciado focado em garantir que o agente validado seja o que os usuários interagem de maneira confiável e repetível. Isso requer uma abordagem estruturada que mova o agente de um ativo com controle de versão para um serviço monitorado ativo.

1. Empacotamento e controle de versão: Toda a definição do agente, incluindo seus avisos e ferramentas, é capturada como metadados em um arquivo e armazenada em um sistema de controle de código-fonte, como o Git. Isso cria uma única fonte da verdade e um histórico auditável de todas as alterações.
2. Pipelines CI/CD: O caminho para produção é automatizado para eliminar erros humanos e garantir a consistência. Esses pipelines promovem automaticamente o agente por meio de ambientes de desenvolvimento, teste e produção, executando testes de ponta a ponta em cada estágio para atuar como um gateway de qualidade.
3. Estratégias de distribuição em fases: Para minimizar o risco, novas versões do agente são lançadas para um pequeno subconjunto de usuários primeiro usando estratégias como Canary Releases. Isso permite o monitoramento de desempenho do mundo real antes de uma distribuição completa, com a capacidade de reverter rapidamente se algum problema for encontrado.
4. Ativação e governança: A etapa crítica na distribuição de um agente envolve ativar com segurança o agente com as permissões corretas e garantir que ele esteja conectado às ferramentas de monitoramento. Isso fornece visibilidade imediata da integridade e do desempenho do agente recém-implementado do momento em que ele é ativado.

A implantação não é o fim do ciclo de vida de desenvolvimento do agente; é o início de seu "loop externo" contínuo. Os agentes são sistemas dinâmicos que operam em ambientes do mundo real imprevisíveis. Essa fase é dedicada a observar o desempenho ativo do agente, coletar percepções de suas interações e usar esses dados para refinar e melhorar sistematicamente sua eficácia, segurança e eficiência ao longo do tempo.

1. Monitoramento de desempenho em tempo real: Essa é a prática de rastrear as principais métricas operacionais do agente conforme ele interage com os usuários. Os painéis são usados para monitorar a latência, o consumo de token (custo) e as taxas de erro da API, fornecendo uma visão imediata e de alto nível da integridade e da eficiência do agente.
2. A análise comportamental e de sucesso: Isso envolve analisar registros conversacionais para entender como o agente está realmente executando suas tarefas. Ele se concentra em rastrear taxas de conclusão de tarefa, identificar pontos de falha comuns ou "términos inativos" conversacionais e medir a satisfação do usuário para determinar se o agente está atingindo com sucesso suas metas. Como exemplo para agentes de serviço, ele pode fornecer métricas sobre a frequência e o motivo de um agente ser escalado para uma pessoa.
3. Tuning inteligente e refinamento: Esse é o processo ativo de usar percepções do monitoramento para melhorar o agente. Isso pode variar de engenharia de prompts a otimização de ferramentas.
4. Aumento de RAG orientado por dados: A qualidade da base de Knowledge do agente é continuamente melhorada com base em consultas do mundo real. O monitoramento pode revelar que o agente está com dificuldades com determinados tópicos, levando a um refinamento das fontes de dados ou do processo de recuperação (RAG Refinement) para melhorar a precisão de suas respostas.
5. Aprendizagem e adaptação contínuas: Isso envolve a criação de um loop de feedback em que os dados de produção são usados para tornar o agente mais inteligente. Ao rotular registros de interação, seja com supervisão humana ou rotulagem baseada em LLM, um conjunto de dados selecionado é criado, que pode ser usado para ajustar o modelo subjacente e recomendar melhorias adicionais

A Agentforce oferece suporte a todas as fases do ADLC com ferramentas integradas para design, desenvolvimento, teste, implantação, monitoramento e análise, tudo dentro de uma única plataforma unificada para criar e testar rapidamente agentes robustos.

O ADLC da Agentforce baseia-se nos seguintes princípios orientadores:

• Criado para código baixo e pro: Suporte para implementação baseada em configuração (baixo código) e extensibilidade programática (procódigo).
• Loops contínuos de assistência e feedback conduzidos por IA: Captura e analisa dados conversacionais para informar o ajuste do agente para melhoria contínua conduzida por IA.
• Desenvolvimento orientado por testes em todos os níveis: Teste rigoroso em todos os estágios, validação de componentes determinísticos por meio de testes de unidade tradicionais e fornecimento de novas abordagens para testar o raciocínio do agente e o comportamento não determinístico.
• Observatibilidade executiva e LOB: Fornecer métricas de custo, uso e desempenho para partes interessadas operacionais e executivas.

Este capítulo mostra como a Agentforce suporta cada fase do ADLC dentro de uma única plataforma unificada.

Ideia

A fase de ideologia é o estágio fundamental do ADLC, em que a visão inicial e os requisitos para os agentes são formulados. Ele envolve um aprofundamento na compreensão do problema, identificando soluções em potencial e descrevendo as funcionalidades principais do agente.

Inicie o processo de ideias do seu agente definindo seus principais atributos:

1. Objetivo/alvo: Defina claramente o objetivo principal do agente. Que problema específico ele foi projetado para resolver ou que tarefa ele pretende realizar? Quem o agente deve atender? Esta deve ser uma declaração concisa e mensurável que oriente todo o processo de desenvolvimento.
2. Persona: Desenvolva uma personalidade detalhada para o agente. Isso inclui definir sua identidade, estilo de comunicação e o papel que ela desempenhará na interação com usuários ou outros sistemas. Considere seu tom, seu nível de formalidade e quaisquer características específicas que o tornem eficaz no contexto desejado.
3. Padrão: Identifique e vincule padrões agentes relevantes e estratégias de implementação. Isso envolve designs arquitetônicos ou práticas recomendadas que podem informar a estrutura e o comportamento do agente. "Padrões agentes e implementação no Salesforce Agentforce: Um Whitepaper Técnico", serve como um recurso valioso para essa etapa, oferecendo percepções sobre design de agente eficaz na plataforma Salesforce e Agentforce.

Design

A fase de design traduz os conceitos da ideia para um esquema detalhado para a construção do agente. Isso envolve definir a arquitetura do agente, os fluxos do usuário, os modelos de interação e as especificações técnicas, como tópicos, ferramentas e proteções.

Durante a fase de design, você criará um projeto detalhado para a construção do seu agente que inclui:

• Design do agente: Trace a estrutura interna do agente, incluindo seus componentes, módulos e como eles interagem. Isso pode envolver a definição da base de Knowledge, configuração e lógica para controlar o comportamento do agente, componentes de processamento de linguagem natural (NLP) e pontos de integração com outros sistemas.
• Fluxos de usuário/design de interação: Mapeie a jornada do usuário e as interações do agente. Defina fluxos de conversa, árvores de decisão, tratamento de erros e mecanismos de feedback para criar experiências intuitivas e eficazes.
• Especificações técnicas: Documente os requisitos técnicos não funcionais para o agente, como métricas de desempenho, considerações de escalabilidade, protocolos de segurança e especificações de integração.
• Protótipos & Mockups: Crie representações visuais ou protótipos interativos da interface e das interações do agente. Isso permite testes e feedback antecipados, ajudando a refinar o design antes do início do desenvolvimento em escala total.
• Dados: Ao determinar o tipo e as origens de dados de que um agente precisa, identifique conjuntos de dados, APIs, bancos de dados e repositórios que o agente deve acessar. Para o Agentforce, concentre-se em quais dados são fornecidos como contexto, se são estruturados ou não e se são em tempo real ou em lote. A plataforma Agentforce é construída com integração profunda com o Data 360, permitindo que você use dados estruturados e não estruturados do Salesforce CRM e outras fontes. O conteúdo não estruturado pode ser dividido nativamente em blocos e indexado para RAG. O MuleSoft permite que você se conecte a sistemas externos.
• Ferramentas: Identifique as ações que o agente deve realizar. Use Ações do Agentforce para expor ferramentas que atingem metas de negócio. Essas ações aproveitam ativos existentes do Salesforce, como avisos via Criador de prompts, MuleSoft, Apex, Fluxos e APIs com especificações OpenAPI. Qualquer Ação invocável pode ser integrada ao Agentforce e usada pelo agente, disponibilizando prontamente todas as ferramentas de desenvolvimento do Salesforce como Ações do Agentforce.
• Dados de entrada para agentes: No SDLC tradicional, as entradas são especificadas com precisão. No ADLC, as entradas geralmente são enunciados naturais, não determinísticos e em forma livre. Colete um corpo representativo de enunciados que devem produzir respostas adequadas.

A fase de desenvolvimento se concentra em traduzir o propósito, as capacidades e o escopo operacional do agente definido determinados na fase de Ideação e Design em um novo Agente Agentforce.

Para ajudar os desenvolvedores a criar agentes, o Agentforce fornece tanto o Agent Builder quanto o Agentforce Developer Experience (AFDX). Essas ferramentas fundamentais servem como os ambientes principais para construir e configurar o agente.

• O Agent Builder oferece uma experiência de UI para definir a funcionalidade principal do agente.
• O AFDX fornece uma interface programática para personalização e integração com outros sistemas.

O desenvolvimento e a criação de um agente envolve estas etapas que podem ser realizadas usando o Criador de agentes ou o AFDX:

1. Definindo a Persona: Um aspecto crucial do design do agente é estabelecer uma personalidade distinta. Isso envolve configurar:
   • Descrição do agente: Uma descrição detalhada do papel, dos objetivos do agente e das tarefas específicas de atendimento ao cliente que ele foi projetado para lidar.
   • Tone: O estilo de comunicação do agente, o nível de empatia e as diretrizes da marca específicas que ele precisa seguir.
2. Definindo tópicos e ações do agente: Para tornar um agente sofisticado e capaz de lidar com uma variedade de tarefas, é essencial dividir seus recursos em tópicos distintos com ações correspondentes.
   • Tópicos: Cada tópico pode ser conceptualizado como seu próprio agente especializado com um conjunto exclusivo de instruções e ferramentas.
     • Arquitetura Modular. A abordagem modular aos tópicos permite maior organização e escalabilidade. Ao definir vários tópicos, o agente pode lidar com uma gama mais ampla de cenários complexos. Por exemplo, um agente pode ter tópicos separados para "Gerenciamento de pedidos", "Perguntas frequentes (FAQ)," Suporte técnico" e "Faturamento de consultas".
   • Instruções do tópico (Guardrails): Cada tópico vem com instruções específicas que atuam como proteções, definindo o escopo do que o agente pode discutir ou fazer nesse tópico. Essas instruções impedem que o agente desvie o tópico ou forneça informações irrelevantes. Eles também ajudam a manter a consistência e a precisão das respostas.
   • Ações: Os tópicos também são equipados com "ferramentas", que representam as ações que o agente pode realizar. Essas ferramentas podem ser:
     • Ações de informação: Recuperação de dados de uma base do Knowledge ou de um sistema externo para responder a uma consulta.
     • Ações transacionais: Executar ações em nome do usuário, como fazer um pedido, atualizar um registro de cliente ou iniciar um processo de reembolso. Essas ações costumam ser integradas a outros sistemas (por exemplo, CRM, ERP).

Ao avaliar o desempenho e a confiabilidade dos agentes de IA, os testadores costumam encontrar uma variedade de desafios que podem prejudicar a experiência do usuário. Esses problemas vão desde a interpretação incorreta da intenção do usuário até a falha na execução correta das tarefas.

Cenários comuns de falha do agente

Criar um agente robusto exige entender como e onde ele pode falhar. A tabela a seguir categoriza problemas comuns encontrados durante o ciclo de vida do agente, desde o raciocínio defeituoso até a recuperação de Knowledge deficiente. Use isso como um guia estratégico durante o desenvolvimento e uma lista de verificação durante os testes para garantir que seu agente seja não apenas funcional, mas também confiável e intuitivo para o usuário final. Esses cenários de falha devem ajudá-lo a definir casos de teste.

Práticas recomendadas para testar agentes de IA

A seguir, apresentamos as melhores práticas a serem consideradas ao testar Agentes no Agentforce.

1. Aumentar dados de teste
   A base de testes eficazes são dados de teste abrangentes e realistas. Siga estes princípios para garantir que você tenha dados de teste eficazes para testar seus agentes:

   • Cobertura suficiente: Tente ter dados de teste suficientes para cobrir todos os tópicos críticos e as personas do usuário.
   • Cenários realistas: Garanta que seus dados de teste representem com precisão interações do usuário do mundo real.
   • Casos negativos e de ponta: Inclua casos de teste negativos (o que o agente não deve fazer) e cenários de borda para desafiar os limites do agente.
   • Teste de proteção: Adicione casos de teste específicos projetados para verificar se as proteções do agente estão funcionando corretamente.

2. Otimizar execuções de teste
   Para aproveitar ao máximo seus recursos de teste, otimize como você executa seus testes. As seguintes são considerações ao testar agentes Agentforce:

   • Volume do caso de teste: Você pode utilizar até 1.000 casos de teste.
   • Executar testes simultâneos: É possível executar até 10 casos de teste por vez em um período de 10 horas.
   • Gerenciar recursos: Lembre-se de que a execução de testes consome créditos. Certifique-se de estar satisfeito com seus dados de teste antes de iniciar uma execução para evitar custos desnecessários.

3. Resultados da revisão
   Analise cuidadosamente os resultados dos testes para identificar áreas para melhoria:

   • Analisar falhas: Inspecione cada caso de teste com falha individualmente. Leia com cuidado e entenda a diferença entre os resultados esperados e os resultados reais para detectar o problema.
   • Usar um ambiente de sandbox: Os agentes de teste podem modificar dados do CRM. Para evitar alterações inadvertidas em seus dados ativos, sempre realize testes em um ambiente que não seja de produção, como um sandbox ou uma organização teste.

4. Tone e reteste
   O teste é um processo iterativo que continua conforme o agente evolui:

   • Teste continuamente: Realize testes após cada modificação nos tópicos ou ações do agente. Isso valida as alterações e garante que a qualidade seja mantida.
   • Expandir a cobertura de teste: Organize e expanda continuamente seu conjunto de dados com novos casos de teste para melhorar a cobertura geral e a robustez do agente.

Abordagens de teste

Dada a complexidade do agente, nenhum método de teste único é suficiente. Uma estratégia de validação abrangente deve ser estratificada, combinando diferentes abordagens para cobrir tudo, desde ações preditivas e deterministas às nuances de seu comportamento não determinista e conversacional. Essas abordagens fornecem uma estrutura para avaliar sistematicamente cada componente do agente para garantir que ele seja robusto, confiável e seguro.

1. Teste manual com o Agent Simulator e o Plan Tracer

   • Objetivo: Essa é a maneira inicial e frequentemente mais simples de testar um agente. É ideal para um pequeno conjunto de casos de uso de amostra e para obter uma compreensão fundamental do comportamento do agente.
   • Mecanismo: Um simulador de agente fornece um ambiente controlado em que desenvolvedores e administradores podem interagir diretamente com o agente. Esse simulador permite o rastreamento detalhado das informações que o administrador/desenvolvedor está fornecendo, oferecendo percepções sobre como o agente processa entradas e gera saídas.
   • Benefícios:
     • Feedback rápido
     • Fácil identificar problemas imediatos
     • Ajuda a entender o fluxo de lógica do agente

2. Teste automatizado com o Centro de teste ou o AFDX Test Suite

   • Objetivo: Depois que o teste manual estabelece uma linha de base de funcionalidade, o teste automatizado se torna crucial para escalabilidade, detalhamento e teste de regressão.
   • Mecanismo: Ferramentas como o Centro de teste ou o pacote de teste AFDX permitem a geração de testes automatizados com base em casos de uso de amostra predefinidos. Esses testes são projetados para validar se as instruções do agente e as classificações de subagente estão funcionando corretamente em uma gama mais ampla de cenários.
   • Benefícios:
     • Garante um desempenho consistente
     • Identifica bugs sutis
     • Dá suporte a pipelines de integração contínua/implementação contínua (CI/CD)
     • Fornece cobertura abrangente

3. Teste de unidade específico da ação usando Apex e fluxos

   • Objetivo: Para validar a lógica de negócios determinística encapsulada nas ações do agente. Embora o comportamento geral do agente não seja determinístico, as ações do agente geralmente são impulsionadas por tecnologias como Fluxos e Apex, às quais se aplicam práticas de desenvolvimento padrão.
   • Mecanismo: Os desenvolvedores escrevem testes de unidade para os Fluxos específicos ou classes do Apex que uma ação do agente invoca. Esses testes verificam os componentes individuais da lógica do agente, garantindo que eles produzam as saídas esperadas para um determinado conjunto de entradas.
   • Benefícios:
     • Integrar esses testes de unidade em um pipeline DevOps fornece uma rede de segurança automatizada
     • Verifica se quaisquer alterações ou aprimoramentos na lógica de uma ação não introduzem regressões
     • Garante a confiabilidade dos recursos do agente antes de eles serem implementados na produção

4. Ensaios adversários - Segurança e proteção:

   • Objetivo: Criar vários tipos de agentes exige um forte enfoque na segurança e garantir que eles operem dentro de parâmetros e proteções definidos. Isso é essencial para evitar ações indesejadas, violações de dados ou uso indevido. Portanto, o objetivo dos testes adversários é identificar e corrigir proativamente essas possíveis vulnerabilidades desafiando deliberadamente o agente com entradas projetadas para contornar seus mecanismos de segurança, testando assim sua robustez e resistência à manipulação.
   • Mecanismo: Os testes adversários são implementados criando entradas desafiadoras, ambíguas ou mal-intencionadas que aumentam os limites do comportamento pretendido do agente. Embora ferramentas de plataforma como o recurso "Guardrails" no Agent Builder forneçam percepções sobre a adesão à instrução, os desenvolvedores também devem criar casos de teste adversários personalizados que tentem ativamente fazer com que o agente falhe em um ambiente controlado.
   • Benefícios: Essa abordagem mitiga sistematicamente riscos de segurança e conformidade antes da implementação. Ao identificar possíveis pontos de falha, o teste adversário aprimora a confiabilidade do agente e garante que ele funcione com segurança e conforme o desejado ao interagir com os usuários.

Teste iterativo em organizações teste e sandboxes

O "loop interno" é o ciclo crítico e iterativo em que um agente passa do conceito para um componente validado, pronto para implementação. Esse processo de refinamento contínuo requer ambientes para desenvolvimento e teste. A Agentforce fornece essa estrutura por meio de organizações teste, que são isoladas, ambientes temporários para prototipagem rápida que não afetam ambientes compartilhados e sandboxes, que permitem testes completos com dados realistas para acelerar o caminho para a produção.

1. Desenvolvimento em Organizações de rascunho: O desenvolvimento inicial deve ocorrer em uma organização teste. As ferramentas fornecidas no ambiente de desenvolvimento, como o Agent Builder e o AFDX, são totalmente utilizadas aqui. Organizações teste são candidatos fortes para pipelines CI/CD para executar testes de unidade, realizar análise de código e promover alterações para ambientes mais altos.
2. Implantação em sandbox para teste de dados reais: Depois que as funcionalidades principais do agente forem desenvolvidas em uma organização teste, implante-as em um sandbox. Os sandboxes são cópias de um ambiente de produção, oferecendo um terreno de teste mais realista.
   • Dados real vs. Dados simulados: Embora alguns desenvolvedores possam simular dados em organizações teste para teste inicial, implantar em um sandbox permite testar com "dados reais". Isso é essencial para avaliar o desempenho do agente em cenários que espelham de perto as interações reais com o cliente. Usar dados mais representativos em um sandbox acelera significativamente o processo de desenvolvimento e refinamento.
   • Sandbox completo ou parcial para o Core CRM Data: Dependendo do volume de dados e dos requisitos de teste específicos, um sandbox completo ou parcial pode ser utilizado.
     • Sandbox completo: Fornece uma réplica completa do ambiente de produção, incluindo todos os metadados e dados. Ideal para testes extensos e ajuste de desempenho com grandes conjuntos de dados.
     • Sandbox parcial: Contém um subconjunto dos dados de produção, geralmente suficiente para testar recursos ou funcionalidades específicos em que um conjunto de dados completo não é estritamente necessário.
   • Knowledge and RAG Management: Se o agente depender de uma base de Knowledge ou modelo de Geração de recuperação ampliada (RAG), ingerir todo o conteúdo relevante no sandbox e indexá-lo novamente. Isso garante que o agente use informações atuais durante os testes e possa recuperar e sintetizar conteúdo com precisão.

O Agentforce define agentes por meio de metadados para que eles possam ser implementados usando procedimentos padrão do Salesforce, como Conjuntos de alterações ou AFDX. Essa fase enfatiza uma distribuição segura e controlada por meio de recursos críticos, como controle de versões do agente e uma etapa de ativação separada, que garante a estabilidade do sistema e permite a recuperação rápida de problemas.

Siga estas etapas para implementar e liberar seu novo agente.

1. Implante por meio da API Change Set/Metadata ou AFDX: O processo de implantação para agentes aproveita os procedimentos padrão do Salesforce, tratando os agentes como metadados. Esse deve ser um processo familiar para qualquer pessoa acostumada ao desenvolvimento e à implantação do Salesforce. Usar conjuntos de alterações ou AFDX garante uma abordagem estruturada e consistente para migrar configurações de agente entre ambientes, como de sandbox para produção. Esse método facilita o controle de versão e o gerenciamento de alteração adequado, que são cruciais para manter a estabilidade e a confiabilidade do sistema.
2. Ativar agentes pós-implementação: Após uma implantação bem-sucedida, é imperativo que um administrador do sistema "ative" ativamente o agente. A implantação simplesmente coloca o código e os metadados do agente no ambiente de destino; a ativação é a etapa que torna o agente operacional e disponível para uso. Essa separação permite distribuição e teste controlados antes de um agente ficar ativo e interagir com usuários finais ou outros componentes do sistema.
3. Usar controle de versões para gerenciamento seguro de agentes: O controle de versões do agente é um recurso crítico que melhora significativamente a segurança e a flexibilidade do desenvolvimento e da manutenção do agente.
   1. Criando, testando e publicando novas versões: A prática recomendada envolve a criação de uma nova versão de um agente sempre que alterações ou aprimoramentos forem necessários. Essa nova versão pode então ser totalmente testada em um ambiente de sandbox sem afetar o agente ativo ativado. Quando a nova versão for validada e considerada pronta, ela poderá ser publicada e, posteriormente, ativada, substituindo a versão operacional anterior. Esse processo iterativo permite melhoria e inovação contínuas enquanto minimiza as interrupções.
   2. Rollback para versões anteriores: Um benefício importante do controle de versões é a capacidade de reverter rapidamente e facilmente para uma versão estável anterior se ocorrer um problema com um agente recém-implementado ou ativado. Se algo der errado, por exemplo, se um agente se comportar mal ou introduzir um erro imprevisto, os administradores podem simplesmente voltar para a última versão positiva conhecida e ativá-la. Esse recurso fornece uma rede de segurança crítica, permitindo recuperação rápida e minimizando o tempo de inatividade, garantindo a continuidade dos negócios e a satisfação do usuário.

Monitoramento de agente

O Rastreamento de sessão do Agentforce é um modelo aberto e extensível criado no Data 360 que captura interações entre agentes. O rastreamento de sessão do Agentforce ingere dados de diferentes fontes (a começar pelos logs do mecanismo de raciocínio) e combina tudo sob um ID de sessão.

O Modelo de dados de rastreamento de sessão (STDM) fornece informações detalhadas sobre o que aconteceu durante as sessões do agente, incluindo:

• Interações de turno a turno
• Justificando execuções de mecanismo
• Ações, entradas/saídas de prompt e gateway
• Mensagens de erro
• Respostas finais

O STDM é uma ferramenta crítica para ajudar os desenvolvedores a:

• Depurar problemas de configuração e configuração do agente durante o tempo de criação.
• Saiba por que determinados casos de teste falharam durante os testes em lote.
• Entenda por que um agente não consegue lidar com um conjunto de perguntas do usuário ou está saindo do tópico.

Os desenvolvedores devem usar esses dados de rastreamento de sessão para observar, monitorar, investigar e solucionar problemas de eventos, incidentes e padrões de comportamento do agente.

O STDM consiste em Objetos de data lake (DLOs) e Objetos de modelo de dados (DMOs) que armazenam registros detalhados do comportamento do agente. Metadados sobre cada chamada de LLM feita pelo mecanismo de raciocínio podem ser unidos a métricas de feedback ou de proteção. Os dados fluem para DLOs no Data 360 e são mapeados para os DMOs aplicáveis.

Os desenvolvedores podem acessar esses dados e obter percepções executando consultas e relatórios em relação ao STDM. Os componentes de um STDM são descritos abaixo.

Modelo de dados de rastreamento de sessão do Agentforce ERD

Otimização do Agentforce

A Otimização do Agentforce é um recurso poderoso projetado para melhorar o desempenho dos agentes de IA fornecendo percepções aprofundadas sobre as interações com o usuário. Criado com base nos recursos de análise do Modelo de dados de rastreamento de sessão (STDM), ele permite que administradores e desenvolvedores entendam tópicos do usuário, padrões de engajamento e a eficácia das resoluções do agente.

Os principais aspectos da otimização do Agentforce incluem:

• Dados específicos do momento: A Otimização do Agentforce estende o STDM introduzindo "Moments", que representam interações focadas em uma intenção ou solicitação de usuário específica durante uma sessão. Esses dados granulares permitem uma inspeção detalhada de cada aspecto de uma interação, da solicitação inicial do usuário à resolução do agente.
• Processamento de momento automatizado: Os momentos são gerados diariamente e, em seguida, agrupados e marcados semanalmente em todos os agentes ativos usando um Modelo avançado de idioma grande (LLM). Essa segmentação simplifica a consulta e fornece percepções sobre várias facetas de sessões do agente.
• Quering e análise: Os usuários podem consultar Moments com base em marcas, pontuações de qualidade e outros critérios. Isso habilita a avaliação do engajamento do usuário por meio de métricas como duração do Momento e pontuações de qualidade de relevância, ajudando a detectar áreas para melhoria.
• Modelo de dados unificado: A otimização do Agentforce utiliza o modelo de dados unificado de rastreamento de sessão (STDM), que captura todos os eventos registrados em uma sessão, incluindo turnos de conversa individuais. Todas as entidades relevantes são provisionadas ao habilitar o STDM na configuração.

Ao analisar interações entre agentes de IA, a otimização do Agentforce permite aos usuários identificar áreas para melhoria e refinar as configurações para atender melhor às necessidades dos usuários.

Para obter mais informações, consulte Modelo de dados para otimização do Agentforce.

Este capítulo é um guia prático para desenvolvedores de código profissional. Ele mostra como criar, testar e implementar agentes com Agentforce DX (AFDX) e nosso SDK do Python com rapidez e segurança. Vamos percorrer todo o ciclo de vida, do design inicial até um agente com controle de versão, usando a poderosa combinação de AFDX e nosso SDK do Python.

Os exemplos a seguir aproveitarão dois conjuntos de ferramentas importantes projetados para criar e gerenciar agentes na plataforma Agentforce. É recomendável ter uma compreensão fundamental dessas ferramentas para aproveitar ao máximo este guia.

1. Agentforce DX (AFDX): Para gerenciar o ciclo de vida

O Agentforce DX estende o conjunto de ferramentas familiar do Salesforce Developer Experience (SFDX), incluindo as extensões Salesforce CLI e VS Code, para dar suporte a todo o ciclo de vida de desenvolvimento do agente. Ele é usado para gerenciar um agente como metadados controlados por versão, automatizar testes na linha de comando e orquestrar implantações entre seus sandboxes de desenvolvimento e produção.

Para aprender mais, consulte: Introdução ao Agentforce DX Development.

2. SDK do Agentforce Python: Para criar o agente

O SDK do Python fornece a interface programática para o "loop interno" de desenvolvimento. Permite que você defina a lógica de raciocínio de um agente, conecte suas ferramentas e gerencie modelos de prompts diretamente em um ambiente do Python familiar, simplificando a fase principal de construção do ADLC.

O SDK está disponível no PyPI: https://pypi.org/project/Agentforce-sdk/.

O projeto completo está disponível aqui:
https://github.com/akshatasawant9699/ADLC_Whitepaper.

Essa fase fundamental define a finalidade, a persona e os principais recursos de um agente. Ele envolve responder a perguntas críticas para arquitetar o "cérebro" do agente antes de qualquer código ser escrito. Neste exemplo, estamos projetando um agente para Coral Cloud Resorts.

• Missão: O agente atua como gerente de resort, lidando com reclamações do cliente, gerenciando agendas do funcionário e garantindo uma operação tranquila do resort.
• Persona: O agente tem um tom útil, profissional e conversacional.
• Ferramentas e funcionalidades: O agente precisa de acesso a sistemas de reserva, software de agendamento de funcionários e políticas de resort.
• Lógica de decisão: O agente usa tópicos gerados por IA para determinar a intenção do usuário e gerar ações adequadas.

Com o Agentforce DX, a fase de projeto se traduz em um arquivo de especificação tangível: Agentforce DX: Gerando uma Especificação do agente. A primeira etapa da jornada de pro-código é gerar um arquivo agentSpec.yaml. O arquivo YAML captura o design principal do agente, incluindo seu papel, detalhes relevantes da empresa e uma lista gerada por IA de tópicos que definem os trabalhos que ele pode lidar.

Use o Salesforce CLI para gerar essa especificação por meio de avisos interativos. Para começar a criar seu agente com Agentforce DX, execute:

Você precisará fornecer detalhes específicos que foram definidos durante a fase de ideias:

• Tipo de agente: Cliente
• Nome da empresa: Estâncias do Coral Cloud
• Descrição da empresa: A Coral Cloud Resorts fornece aos clientes atividades de destino excepcionais, experiências inesquecíveis e serviços de reserva, tudo apoiado por um compromisso de fornecer um atendimento ao cliente de alto nível.
• Papel do agente: O gerente do resort processa as reclamações do cliente, gerencia agendas do funcionário e garante que todos os processos estejam funcionando sem problemas.

Executar esse comando cria um arquivo agentSpec.yaml no diretório specs do projeto DX. O arquivo contém as informações que foram fornecidas junto com uma lista de tópicos gerados por IA que inclui o nome e a descrição de cada tópico. Revise e edite o arquivo conforme necessário para refinar os recursos do agente.

Da mesma forma, a implementação do SDK do Python usa a coleção de especificações interativas para gerar tópicos do agente automaticamente com os campos de escopo adequados necessários para compatibilidade com o SDK.
Além disso, ele criará um arquivo JSON de especificação do agente completo que será usado para criar um agente na Fase 2.

A fase de desenvolvimento se concentra em construir os componentes centrais do agente: o mecanismo de raciocínio, as ferramentas que ele pode usar e sua base Knowledge. Agentforce abstrai grande parte da complexidade, o que permite que os desenvolvedores se concentrem na lógica de negócios.

Esta seção compartilha duas abordagens pro-código para a fase de desenvolvimento do Agentforce. Em primeiro lugar, usando o Agentforce DX e em segundo lugar usando o Python.

Agentforce DX: Criar um agente a partir de uma especificação

Quando o arquivo agentSpec.yaml estiver pronto, crie o agente em sua organização do Salesforce. Execute este comando para criar o agente e sincronizar seus metadados associados de volta com seu projeto DX local:

Quando solicitado, aceite o nome de API padrão, Resort_Manager. O comando analisa a especificação, cria o agente e recupera os metadados. Os metadados incluem um Bot, BotVersion e um GenAiPlannerBundle, que adicionam inteligência de IA e referências aos tópicos e ações do agente.

Visualize a estrutura do agente antes de criá-la adicionando o sinalizador --preview para gerar um arquivo JSON local que detalha o tipo de agente que o LLM será criado, incluindo ações sugeridas. Por exemplo:

Para obter mais informações, consulte Criar um agente usando seu projeto DX no Trailhead.

SDK do Agentforce Python: Definir ferramentas específicas

O SDK do agente facilita o teste do agente criando ações simuladas. Essas ações simuladas eventualmente precisarão ser substituídas por ações reais no Salesforce. O Salesforce oferece uma variedade de recursos de plataforma, incluindo Fluxos, Apex, Modelos de prompt e APIs, que podem ser encapsulados como ações do Agentforce.

Aqui está um snippet de código de ação simulado para ilustrar a aparência de uma ação do Agentforce.

A implementação estabelece a conexão com o Salesforce, cria a instância do agente e define ferramentas e ações personalizadas que o agente pode usar para interagir com sistemas externos e realizar funções de negócios específicas.

Como discutimos acima, testar um agente é mais complexo que testar software tradicional. Ele exige validação de comportamento, raciocínio e robustez em vários cenários. Isso inclui testes de unidade para ferramentas individuais, testes completos para conversas e testes adversários para encontrar vulnerabilidades.

O Agentforce DX fornece um fluxo de trabalho de alto nível para criar, implementar e executar testes, além do Centro de teste e da API de teste direta. Esta seção demonstra a execução de testes com Agentforce DX.

Agentforce DX: Executar um teste de agente

Use o Agentforce DX para executar testes de agente predefinidos diretamente na linha de comando. Isso é ideal para integrar o teste do agente a processos DevOps modernos.

SDK do Agentforce Python: Simular testes E2E e adversários

Conceitualmente, o Python SDK permite conversas com script para simular testes de ponta a ponta (E2E) e validar o raciocínio do agente.

SDK do Agentforce Python com API de teste do Salesforce

A implementação do SDK do Python usa testes abrangentes com a API de teste do Salesforce e metadados AiEvaluationDefinition, criando casos de teste estruturados com expectativas para sequências de tópicos, sequências de ações, correspondência de string e métricas de qualidade. O sistema gera definições de metadados XML que podem ser implementadas no Salesforce para teste e validação automatizados do agente.

Após a validação, o agente é implementado em um ambiente de produção. Durante essa fase, o Agentforce DX é crucial para ajudar a gerenciar e mover metadados do agente entre diferentes organizações (por exemplo, sandboxes e produção). As implantações do agente criam uma nova versão do Agente e o Agente não é ativado até você ativá-lo explicitamente. Isso lhe dá controle total de quando lançar a nova versão do agente.

Agentforce DX: Implementar metadados do agente

A estrutura de projeto padrão Salesforce DX organiza os metadados do agente no diretório force-app. Use os comandos padrão sf project deploy para implantar um agente e seus testes associados em uma organização de destino.

Depois que um agente é criado ou implementado, você pode abri-lo diretamente na interface do usuário do Agentforce Builder para verificar sua configuração executando:

Depois de validar que o agente está implantado, você pode ativá-lo. Se você encontrar algum problema inesperado, volte para a versão de trabalho anterior do agente.

SDK do Agentforce Python: Implantação da implantação do agente

A implementação pega a especificação de agente validada e a implanta na organização do Salesforce, disponibilizando o agente para uso. O processo de implantação inclui criação de agente, sincronização de metadados e verificação de implantação bem-sucedida.

O ADLC é um ciclo contínuo; a implantação não é o fim. Os agentes são sistemas ativos que exigem monitoramento constante para rastrear métricas como latência, custo e taxas de sucesso. As percepções obtidas do monitoramento são usadas para ajustar e melhorar o desempenho do agente por meio da engenharia rápida, otimização de ferramentas e refinamento de bases de Knowledge.

A plataforma Agentforce fornece painéis e análises abrangentes para apoiar esta fase crucial, garantindo que os agentes continuem evoluindo e melhorando ao longo do tempo.

Agentforce Analytics

O Agentforce Analytics, encontrado na pasta Agentforce (padrão), usa o Data 360 para fornecer percepções sobre o desempenho do agente. O painel personalizável e os relatórios oferecem dados sobre adoção, feedback e uso, ajudando você a refinar tópicos e ações para melhorar a satisfação do usuário. Você pode detalhar os resultados clicando em gráficos ou relatórios vinculados. Para personalizar, clone relatórios existentes e modifique os clones para evitar a interrupção de processos de análise.

Análise de enunciado

A Análise de enunciados mostra como os usuários do Agentforce (padrão) estão usando os agentes, o que eles estão solicitando e se o agente conseguiu lidar com essas solicitações. Esses relatórios personalizáveis podem ajudá-lo a refinar seus tópicos e ações para que seus agentes respondam de modo mais eficaz e preciso.

SDK do Agentforce Python: Monitoramento com integrações do Data 360

A implementação do SDK do agente usa monitoramento e análise avançados com o Conector do Python do Data 360, estabelecendo conexão com o Salesforce Data 360, consultando métricas de desempenho do agente e criando painéis de monitoramento abrangentes.
O sistema rastreia tempos de resposta, taxas de sucesso, satisfação do usuário e métricas de custo para fornecer percepções úteis para otimização do agente.

Agentforce DX: Monitoramento de agente

A implementação usa comandos AFDX padrão com gerenciamento de agente baseado em CLI, mantendo o agente atualizado sobre alterações de plataforma e incorporando feedback do usuário para melhoria contínua.

Consulte o repositório do GitHub aqui para implementação do ADLC usando o Agente SDK e AFDX.

Dominar o ciclo de vida de desenvolvimento do agente requer aderir a um conjunto de princípios centrais que garantem eficiência, confiabilidade e alinhamento estratégico. As diretrizes a seguir sintetizam as principais lições de cada fase do ADLC em uma estrutura estratégica para arquitetos e desenvolvedores.

1. Planejamento e idealizando

Essa fase inicial se concentra em alinhar a finalidade do agente às metas de negócio e garantir que ela seja criada em uma base sólida.

• Priorizar para impacto comercial: Comece mapeando casos de uso em potencial diretamente para metas de negócio estratégicas. Use uma matriz de priorização para pontuar seu impacto potencial e começar com um único caso de uso focado com KPIs claros.
• Involver as partes interessadas precocemente: Colete percepções sobre pontos dolorosos e garanta o alinhamento.
• Insights de dados de alavancagem: Um agente é tão bom quanto seus dados. Use o Data 360 para explorar dados estruturados e não estruturados disponíveis para informar o contexto e as capacidades do agente. Revise relatórios e painéis existentes para identificar tendências atuais que podem informar sua seleção de caso de uso.
• Usar estruturas para ideias: Aplique métodos de ideias estruturadas a um brainstorming e refine possíveis aplicativos, como pensamento de design ou análise SWOT.

2. Agentes de construção

Essa fase abrange as práticas recomendadas para criar um agente de alto desempenho e eficiente.

• Evite muitos tópicos: Limite o número de tópicos para reduzir o risco de criar tópicos semelhantes ou sobrepostos que possam confundir o agente.
• Mantenha as instruções e avisos concisos: Use linguagem direta e simples e forneça enunciados de exemplo para orientar o agente de modo eficaz.
• Variáveis de alavancagem e ações determinísticas: Use essas ferramentas para orientar o comportamento do agente e otimizar seu desempenho para resultados mais previsíveis.
• Manter saídas de ação pequenas e concisas: Garanta que as respostas do agente sejam breves e precisas. Saídas mais longas usam mais contexto e são mais lentas para serem geradas.
• Otimizar ações para velocidade: Projete fluxos e classes do Apex para retornar o mínimo de dados necessários. Tente ter menos ações necessárias para gerar uma resposta pré-processando quando possível.
• Definir um escopo claro: Escreva descrições, instruções e escopo adequados para ações para evitar que o agente ligue para RAG (Geração de recuperação ampliada) para perguntas fora do escopo.
• Usar pesquisa híbrida com moderação: Use a pesquisa híbrida apenas se isso for absolutamente necessário, pois isso pode afetar negativamente a latência.

3. Teste, monitoramento e ajuste

Essa fase iterativa é crucial para refinar a precisão e o desempenho do agente.

• Estabelecer um fluxo de teste: Siga um ciclo de teste consistente:
  1. Executar teste em lote: Execute um conjunto abrangente de testes.
  2. Visualizar pontuações/erros: Analise as métricas de desempenho e identifique falhas.
  3. Inspectar falhas: Examine cada linha de falha para entender a discrepância.
  4. Atualizar agente: Faça os ajustes necessários ao agente ou seus dados de avaliação.
• Revisar informações de rastreamento de sessão: Use o Modelo de dados de rastreamento de sessão e o Explorador de interações do Agentforce para realizar a análise da causa raiz quando problemas ou comportamentos inesperados forem identificados. Ajuste seu agente com base nas informações e continue iterando seu agente.

O Ciclo de Vida de Desenvolvimento de Agente representa uma evolução crítica dos princípios tradicionais de desenvolvimento de software, projetados para a era dos sistemas inteligentes e autônomos.

• Evolução, não substituição: O ciclo de vida de desenvolvimento do agente estende e aprimora o gerenciamento de ciclo de vida do aplicativo tradicional sem substituí-lo.
• Dados como um cidadão de primeira classe: Os dados desempenham um papel muito mais dinâmico e central no desenvolvimento do agente.
• Ferramenta especializada & Habilidades: Requer novas ferramentas e um conjunto mais amplo de habilidades especializadas em ciência de dados, engenharia de ML e desenvolvimento de agente.
• Aprendizagem contínua: O desenvolvimento de agentes adiciona aprendizagem contínua e adaptação do próprio sistema.
• Impacto futuro: A IA agente promete automatizar e otimizar ainda mais operações de TI complexas e fluxos de trabalho de desenvolvimento de software.