A primeira semana da Sprint PrograMaria + StackSpot AI formou a base para você compreender como a Inteligência Artificial moderna evoluiu para muito além de chatbots e sistemas de recomendação, chegando ao ponto atual: agentes autônomos capazes de executar tarefas reais, cooperar entre si e integrar-se com sistemas corporativos.

O objetivo desta semana foi nivelar conhecimento entre pessoas iniciantes e profissionais experientes, criando uma base sólida para que todas conseguissem projetar e implementar agentes autônomos de forma técnica, segura e orquestrada.

Este artigo resume todo o conteúdo ensinado, incluindo explicações completas sobre:

• Inteligência Artificial
• LLMs
• StackSpot AI
• Agentes
• Ferramentas, protocolos, memória e execução
• Squads híbridas
• Orquestração multiagente
• Monitoria, logs e avaliação
• Preparação para o desafio final

1. Inteligência Artificial: a base conceitual

A IA utilizada hoje não é mais feita apenas de regras fixas, ela é sustentada por modelos probabilísticos complexos, especialmente as LLMs, que conseguem reconhecer padrões e gerar conteúdo novo a partir de enormes volumes de dados.

A IA moderna é essencialmente um sistema de raciocínio por linguagem, onde o modelo aprende a prever a próxima palavra, sentença ou ação a partir de milhares de exemplos. Isso permite que ela compreenda contexto, explique conceitos, escreva código, gere documentos e analise dados.

Mas o ponto fundamental aqui é: uma IA não é só um chatbot, ela é um componente dentro de sistemas maiores.

2. LLMs: o mecanismo de raciocínio

As LLMs são o núcleo de “inteligência” dos agentes. Elas funcionam como mecanismos de inferência baseados em transformers, interpretando textos e produzindo raciocínios coerentes. Um modelo transformer é uma rede neural que aprende o contexto e, assim, o significado com o monitoramento de relações em dados sequenciais como as palavras desta frase.

Para iniciantes, a melhor analogia é:

“Uma LLM é como um cérebro matemático treinado para pensar em forma de texto.”

Para especialistas:

“É um modelo auto-regressivo otimizado com atenção multi-head, embeddings densos e capacidade de raciocínio step-by-step.”

Mas LLM não executa nada sozinha. Ela só pensa, prediz e decide. Quem executa é o agente.

3. StackSpot AI: o ambiente corporativo de agentes autônomos

Durante essa semana, a StackSpot AI foi o nosso ambiente utilizado como laboratório técnico.
A plataforma nos permitiu criar, testar, monitorar e orquestrar agentes de IA corporativos, com segurança, observabilidade e integração nativa com sistemas existentes de forma sem código.

A StackSpot AI fornece:

• runtime de execução de agentes
• definição de personas e regras
• integração com ferramentas e APIs
• mecanismos de memória vetorial
• observabilidade completa (logs, decisões, ações)
• ambiente para construir orquestrações multiagente

Ela resolve o que falta aos LLMs: capacidade real de agir.

4. O que é um agente de IA (tecnicamente)?

Um agente de IA é um sistema computacional autônomo capaz de perceber seu ambiente, interpretar informações, raciocinar sobre objetivos, tomar decisões, executar ações e avaliar resultados de forma iterativa até concluir uma tarefa.

Diferentemente de uma LLM, que apenas gera texto, um agente combina modelo + estado + ferramentas + memória + protocolo de execução.

Tecnicamente, um agente é composto por 6 elementos fundamentais: 

1. Percepção;
2. Raciocínio;
3. Planejamento;
4. Ação;
5. Memória;
6. Observação (feedback). 

Vamos ver cada um deles a seguir:

4.1. Percepção (Input Layer)

O agente recebe sinais do usuário, o começo da interação com o agente. Esse sinais podem ser:

• texto
• arquivos
• APIs
• mensagens de outros agentes
• estado compartilhado
• eventos assíncronos
• memória vetorial

Essa percepção é estruturada em observations, que alimentam o próximo estágio: o raciocínio.

4.2. Raciocínio (LLM / Modelo)

Uma vez com as observations, o agente utiliza um modelo (LLM ou modelo especializado) como núcleo de decisão. A LLM não é o agente, ela é o mecanismo cognitivo dentro dele.

Ela executa:

• decomposição de tarefas
• raciocínio step-by-step
• planejamento dinâmico
• análise de contexto
• escolha de ferramentas
• interpretação de exceções e erros
• tomada de decisão probabilística

Esse processo é chamado de deliberation loop.

4.3. Planejamento (Planning Engine)

Com base no objetivo e contexto, o agente cria e ajusta um plano. Esse plano pode ser explícito (“Aqui está meu plano em 5 passos”) ou implícito (decisão iterativa).

O planejamento envolve:

• sequenciamento de ações
• divisão do problema
• cálculo de dependências
• avaliação de riscos
• criação de hipóteses
• previsão de falhas

4.4. Ação (Tools / External Functions)

Com esse plano feito, o agente então interage com o mundo real através de ferramentas externas, que podem ser:

• APIs REST
• bancos de dados
• sistemas corporativos
• automações
• scripts
• serviços internos

Essa ação obedece a protocolos formais como:

• MCP – Model Context Protocol
• A2A – Agent-to-Agent Protocol
• JSON-RPC / RPC
• FIPA ACL

Para que a ação de chamamento de uma ferramenta seja feita, é imprescindível 4 elementos:

1. método;
2. parâmetros bem definidos;
3. retorno estruturado;
4. tratamento de erros adequado.

4.5. Memória (Vector DB + State)

Diferentemente da maioria dos chatbots, os agentes conseguem manter o estado, o que significa que ele tem a capacidade de lembrar informações, contexto ou histórico de interações anteriores e usar esses dados para influenciar suas respostas ou ações em interações futuras. Essa é a memória.

A memória é dividida entre:

• Memória de curto prazo (state)

Guarda os últimos passos, decisões e observações.

• Memória de longo prazo (Vector DB / Knowledge Sources)

Armazena conhecimento persistente:

• documentos
• políticas
• regras de negócio
• histórico de interações
• dados da empresa

O agente consulta essa memória para evitar alucinações e recuperar fatos.

6. Observação (Feedback Loop)

Após cada ação, o agente recebe um observation, que pode ser:

• um retorno de API
• uma mensagem de erro
• um estado atualizado
• um documento analisado
• um evento inesperado

Com base nessa observação, ele decide:

• seguir o plano
• ajustar o plano
• tentar novamente
• mudar a ferramenta
• pedir mais contexto

Esse processo fecha o ciclo:

Perceber → Pensar → Agir → Observar → Aprender → Repetir

Em termos formais, um Agente de IA é:

um sistema autônomo orientado a objetivos que combina inferência de linguagem (LLM), execução de ferramentas externas, memória persistente, protocolos de comunicação e um ciclo iterativo de raciocínio para completar tarefas em ambientes reais.

Em termos arquiteturais:

Um agente é um Runtime de Execução composto por:

• Cérebro: LLM ou modelo local

• Corpo: ferramentas que permitem agir

• Memória: knowledge sources + estado

• Protocolo: regras de interação

• Monitoria: logs, tracing, avaliações

• Camada de Segurança: políticas de permissão

 

Em termos práticos:

ChatGPT → responde.
Agente → entende, decide, age, valida e repete até concluir.

Em termos de Engenharia:

É a união entre:

• Machine Learning
• Engenharia de Software
• Arquitetura de Sistemas
• Integrações Corporativas
• Segurança, governança, logging e auditoria
• Protocolos de comunicação
• Sistemas distribuídos

5. Knowledge Sources, Spots e Quick Commands

Para que agentes funcionem no mundo real, eles precisam de componentes especializados.

Knowledge Sources

Knowledge Sources são fontes de conhecimento estruturadas que alimentam a memória de longo prazo de um agente dentro da StackSpot AI e funciona como um banco de dados vetorial.
Elas funcionam como a “biblioteca privada” do agente, contendo tudo aquilo que ele precisa saber para executar tarefas com precisão, sem depender exclusivamente da LLM.

Na prática, uma Knowledge Source é um conjunto de documentos, dados ou conteúdos que são:

1. Indexados
2. Partidos em chunks
3. Convertidos em embeddings
4. Armazenados em um Vector DB
5. Consultados pelo agente quando necessário

É assim que agentes na StackSpot AI conseguem lembrar, fundamentar decisões, citar fatos reais, seguir regras corporativas e, principalmente, evitar alucinações.

Por que Knowledge Sources são necessárias?

LLMs não têm memória permanente e não conhecem:

• regras internas da empresa
• processos específicos
• sistemas proprietários
• políticas de segurança
• manual de conduta
• padrões de código do time
• documentação técnica privada
• requisitos de negócio

Sem Knowledge Sources, o agente:

• inventaria respostas
• não seguiria as regras da empresa
• não usaria informações atualizadas
• dependeria 100% do modelo genérico
• seria inconsistente com as políticas internas

Knowledge Sources garantem consistência, governança e precisão factual. Elas são a base de dados da qual o agente tira suas decisões.

O que pode virar uma Knowledge Source?

Tudo o que possa ajudar o agente a executar seu objetivo.

Alguns exemplos:

Documentos

• PDFs técnicos
• manuais de produto
• arquitetura de sistemas
• documentação de APIs internas

Conteúdo organizacional

• • políticas de segurança
  • SLAs
  • processos internos

• guias da empresa

Informações de produto

• • backlog
  • documentos de discovery
  • regras de negócio

• requisitos funcionais

Informações de engenharia

• • padrões de código
  • convenções de arquitetura
  • templates de PR

• resoluções de incidentes anteriores

Bases de conhecimento

• FAQs
• artigos internos
• wikis
• playbooks

Como Knowledge Sources funcionam tecnicamente?

1. 1. A pessoa envia documentos para StackSpot AI.
   2. O sistema divide o conteúdo em chunks (trechos menores).
   3. Cada chunk é transformado em um embedding vetorial.
   4. Esses embeddings são armazenados em um Vector Database.
   5. Quando o agente precisa de informação, ele faz uma busca vetorial.
   6. A StackSpot AI recupera os trechos relevantes.
   7. Esse conteúdo é enviado para a LLM como contexto no prompt.

• A LLM usa esse contexto para pensar e decidir corretamente.

É assim que a StackSpot AI implementa RAG (Retrieval Augmented Generation) de forma nativa.

 

Spots

Os Spots são componentes plugáveis do ecossistema StackSpot AI que adicionam capacidades prontas, integrações, artefatos, templates e funcionalidades reutilizáveis para pessoas desenvolvedoras, engenheiras e criadoras de agentes.

Eles funcionam como “pacotes de poder” que você instala em um agente ou workspace para expandir sua capacidade, muito parecido com instalar uma lib ou plugin, mas pensado para IA corporativa, automação e integração.

Em termos técnicos, um Spot é composto por artefatos versionáveis que podem conter:

• ferramentas (tools)
• integrações com APIs externas
• configurações de autenticação
• workflows prontos
• templates de agentes
• SDKs
• scripts
• documentação técnica interna
• extensões para pipelines

É uma forma padronizada, versionável e segura de adicionar funcionalidades reais ao agente, evitando retrabalho.

 

O que um Spot pode conter?

Spots são extremamente flexíveis. Eles podem incluir:

Ferramentas (Tools)

Funções que o agente pode chamar, por exemplo:

• criar issue no Jira
• consultar uma API interna
• abrir Pull Request no GitHub
• interagir com o Slack
• manipular dados no BigQuery
• extrair informações de documentos internos

Knowledge Sources adicionais

Documentos, políticas e regras específicas daquele domínio.

Templates de agentes

Uma base pronta para criar um agente especialista em:

• QA
• Backend
• Segurança
• Product Discovery
• Documentação
• Governança

Configuração de autenticação

Tokens, permissões, OAuth, secrets necessários para ferramentas.

Scripts e automações

Workflows reutilizáveis, como:

• rodar testes
• analisar logs
• validar padrões
• formatar código

 

Como os Spots funcionam na prática?

Quando você adiciona um Spot ao seu agente, você está trazendo um conjunto de capacidades pré-embaladas, como se fossem extensões certificadas.

O fluxo técnico é assim:

1. Você adiciona um Spot ao projeto do agente.
2. O Spot registra novas ferramentas disponíveis para o agente usar.
3. Ele adiciona configurações necessárias (auth, endpoints, schemas).
4. Ele pode anexar Knowledge Sources específicas do domínio.
5. A LLM passa a enxergar essas ferramentas como parte do “corpo” do agente.
6. O runtime permite que o agente use essas ferramentas quando necessário.

É um processo semelhante a adicionar:

• uma lib PyPI (Python)
• um pacote npm (JavaScript)
• um plugin terraform
• uma extensão VSCode

Só que para IA.

Quick Commands

Quick Commands são ações rápidas, acionadas sob demanda, que usam uma LLM para executar tarefas pontuais, sem a complexidade de um agente completo.

Eles são uma forma rápida, leve e direcionada de usar IA dentro da StackSpot AI para:

• gerar conteúdos
• revisar textos
• analisar códigos
• transformar arquivos
• realizar verificações
• executar tarefas simples

Tudo isso sem criar um ciclo de raciocínio complexo, sem memória permanente, sem ferramentas externas e sem a autonomia típica de um agente.

Em termos técnicos:

Um Quick Command é:

“uma instrução parametrizada, processada por um modelo de linguagem, que executa uma tarefa imediata com comportamento determinístico e sem estado persistente.”

Ele não tem:

• loops internos
• tomada de decisão iterativa
• orchestrator
• toolkit
• chamadas a APIs externas (exceto quando parte de um Spot específico)
• memória contextual preservada
• plano de ação multi-etapas

É puramente input → inferência → output.

Por que eles existem?

Quick Commands resolvem um problema importante: nem toda tarefa merece um agente completo.

 

Às vezes, a pessoa só precisa:

• revisar um código
• traduzir um documento
• gerar testes unitários
• melhorar um texto
• resumir um PDF
• criar um e-mail
• analisar logs

Criar um agente só para isso seria mais lento e, até mesmo, custoso. Os Quick Commands entregam velocidade + simplicidade que esse tipo de necessidade pede.

O que Quick Commands podem fazer?

✔ Escrita e revisão

• melhorar textos
• corrigir ortografia
• reescrever versões
• adaptar tom de voz

✔ Desenvolvimento

• gerar código
• explicar código
• revisar PRs
• sugerir refatoração
• detectar vulnerabilidades simples

✔ QA

• gerar cenários de teste
• validar critérios de aceite
• criar documentação

✔ Produto / UX

• sumarizar entrevistas
• organizar requisitos
• criar user stories

✔ Dados

• interpretar tabelas
• gerar queries SQL

6. Como agentes trocam informações

Agentes de IA não funcionam como chatbots isolados, eles fazem parte de sistemas distribuídos, onde cada agente pode ter um papel: pesquisador, planejador, executor, especialista, revisor etc.

Para que isso funcione, os agentes precisam comunicar intenções, dados, resultados e estados, exatamente como times humanos fazem.

Tecnicamente, agentes trocam informações através de protocolos, mensagens estruturadas, memórias compartilhadas ou por meio de um orquestrador.

Abaixo está a anatomia completa desse processo.

 

6.1. O modelo fundamental: Mensagens Estruturadas

A forma básica de comunicação entre agentes é via mensagens formais, quase sempre em JSON, contendo:

• tipo da mensagem
• conteúdo
• intenção
• contexto
• estado atual
• resultado parcial
• erros ou exceções
• metadados (quem enviou, quem deve receber)

Exemplo técnico:

{

  "from": "agente_planejador",

  "to": "agente_executor",

  "type": "task",

  "goal": "criar uma PR corrigindo X",

  "payload": {

    "arquivo": "src/service.py",

    "correcao": "ajustar validação"

  }

}

Isso permite que agentes se entendam sem ambiguidade.

6.2. Formas de comunicação entre agentes (as 3 arquiteturas)

A. Comunicação direta (Agent-to-Agent / A2A)

É o formato mais moderno e flexível.

Um agente envia mensagens diretamente para outro, usando protocolos padronizados como:

• A2A Protocol
• FIPA ACL (clássico, mas ainda muito usado)
• JSON-RPC
• Mensagens via MCP

Nessa abordagem, agentes:

• pedem ajuda
• repassam tarefas
• consultam especialistas
• discutem alternativas
• escalam problemas
• votam entre si
• resolvem conflitos

Cada agente atua como um “microserviço cognitivo”.

B. Comunicação via ambiente compartilhado (Shared State / Shared Memory)

Todos os agentes escrevem e leem em um mesmo “painel”.

Pode ser:

• um arquivo
• uma tabela
• um banco NoSQL
• um documento
• um espaço de memória temporária
• um vector DB com estado compartilhado

Funciona como um quadro branco onde:

• um agente escreve o que descobriu
• outro agente lê e continua
• outro valida
• outro finaliza

É a abordagem usada em frameworks inspirados em sistemas multiagentes cooperativos.

C. Comunicação via Orquestrador (Centralized Coordination)

Aqui existe um agente “maestro” ou um módulo de orquestração que:

• recebe mensagens
• interpreta
• distribui para o agente correto
• coleta respostas
• combina resultados
• decide o próximo passo

Esse modelo é comum em:

• pipelines
• workflows complexos
• agentes complementares
• ambientes corporativos onde a governança é crítica

A StackSpot AI permite esse modelo de forma nativa.

6.3. Protocolos usados na troca de informações

1. MCP (Model Context Protocol)

Permite que uma LLM chame ferramentas e troque mensagens de maneira estruturada. É o protocolo mais moderno hoje.

Suporta:

• mensagens padronizadas
• respostas formais
• erros estruturados
• contexto incremental
• permissões e segurança

Pode ser usado entre agentes.

2. A2A (Agent-to-Agent Protocol)

Focado em colaboração entre agentes e ele permite:

• delegação de subtarefas
• mensagens síncronas e assíncronas
• estados distribuídos
• coordenação descentralizada

É a base para sistemas multiagentes autônomos.

3. JSON-RPC

Comum quando agentes usam ferramentas externas.

Agente 1 → chama a ferramenta → ferramenta retorna → agente processa → envia mensagem ao agente 2.

4. FIPA ACL (padrão clássico)

Define intenções explícitas:

• inform
• propose
• ask
• agree
• refuse
• confirm
• query

Ainda é usado em sistemas de coordenação complexos.

 

6.4. Metáfora técnica, mas perfeita para entender

Se quisermos simplificar:

• A2A → agentes “conversam diretamente”
• Shared Memory → agentes “leem e escrevem no mesmo quadro branco”
• Orchestrator → um “líder” distribui mensagens

O melhor sistema normalmente usa os três ao mesmo tempo.

Resumo final:

Agentes trocam informações através de mensagens estruturadas, estados compartilhados e protocolos formais (como MCP, A2A, JSON-RPC e FIPA ACL).
Eles comunicam objetivos, resultados, erros e decisões, permitindo coordenação autônoma, colaboração distribuída e execução de tarefas complexas em conjunto.

 

7. Squads híbridas: humanos + agentes

Os materiais apresentados mostraram como times modernos combinam:

Humanos: estratégia, julgamento, criatividade, ética, decisão.

Agentes: execução, análise, recuperação de contexto, automação, validação, repetição.

Isso aumenta a produtividade e reduz desperdício cognitivo, permitindo que pessoas foquem no que é criativo e estratégico.

8. Orquestração de agentes

Orquestração é o processo de coordenar múltiplos agentes para trabalhar juntos em um objetivo maior.

Quando você tem apenas um agente, ele faz tudo sozinho. Quando você tem vários agentes, cada um com especialidades diferentes, você precisa de um sistema que decida:

• quem faz o quê
• em que ordem
• como passam informações
• como lidam com erros
• como validam resultados uns dos outros
• como voltar atrás
• quando escalar para outro agente
• quando parar

Isso é orquestração.

Na prática, é como montar um time composto por:

• um agente planejador
• um agente pesquisador
• um agente executor
• um agente revisor
• um agente validador

E garantir que todos trabalhem em harmonia.

Erros comuns em orquestração mal feita

• agentes entram em loop
• agentes competem pela mesma tarefa
• agentes se contradizem
• dados são sobrescritos
• mensagens viram “telefone sem fio”
• ninguém assume a responsabilidade final
• raciocínio se perde
• custos explodem

Por isso, a orquestração bem pensada é crítica.

Exemplo real de orquestração:

Objetivo: “Gerar uma análise de vulnerabilidade da API X”

Fluxo:

1. Planner
   Cria plano em cinco passos.
2. Researcher
   Busca documentação, endpoints e riscos conhecidos.
3. Executor
   Roda ferramentas automáticas, analisa respostas e monta draft.
4. Reviewer
   Avalia se o report segue padrões internos.
5. Compliance Agent
   Valida aderência às normas.
6. Planner
   Consolida e entrega resultado final.

Esse fluxo não seria possível sem orquestração.

Resumo final

Orquestração é o conjunto de mecanismos, protocolos e arquiteturas que coordenam múltiplos agentes autônomos para cooperarem entre si na execução de um objetivo maior.

Ela define papéis, fluxos, troca de mensagens, resolução de conflitos, divisão de tarefas e combinação de resultados, garantindo que agentes funcionem como squads digitais completos, seguros, auditáveis e eficientes.

9. Desafio final da Semana 1

Para consolidar tudo o que foi aprendido, cada participante deve entregar:

1. Um agente especialista em aprendizado de IA
2. Um agente desenvolvedor Back-End
3. Preparação para orquestrar agentes na próxima aula

 

✨ Encerramento, para você, que viveu a Semana 1

Antes de tudo: parabéns! Você chegou até aqui e isso não é pouca coisa.

Esta primeira semana foi intensa e, para muitas pessoas, completamente nova. Entrar no universo da Inteligência Artificial moderna exige coragem, curiosidade e a decisão de não se contentar apenas em usar tecnologia, mas de entender como ela funciona de verdade.

E você fez isso.

Você aprendeu que IA não é “mágica”.
É engenharia, método, arquitetura, raciocínio, protocolo, memória, coordenação, ferramenta, intenção.

Você viu que modelos grandes de linguagem (LLMs) são apenas o início, um componente dentro de algo maior. E descobriu como, a partir deles, surgem agentes autônomos capazes de entender objetivos, planejar, decidir, agir, validar e repetir até alcançar o que foi pedido.

Você aprendeu:

• o que faz um agente ser um agente (e não um chatbot)
• como ferramentas se juntam para que agentes atuem no mundo real
• como Knowledge Sources alimentam a memória de longo prazo
• como Spots ampliam capacidades e padronizam integrações
• como Quick Commands aceleram tarefas rápidas
• como protocolos (MCP, A2A, JSON-RPC, FIPA) estruturam conversas entre agentes
• como monitorar, testar e avaliar o comportamento real de um agente
• como pensar IA como um sistema distribuído, e não como uma resposta solta

Você aprendeu tudo isso em apenas uma semana.

Mas o mais importante não é o conteúdo técnico, é o que ele representa:

Você agora entende como construir um agente de verdade.
Você entrou em um campo que o mercado inteiro está correndo para aprender.
Você não está mais na superfície, está vendo o funcionamento interno.
Você está se preparando para liderar o futuro do desenvolvimento inteligente.

Se durante a semana você sentiu algum desconforto, algum desafio, aquela sensação de “meu Deus, isso é muita coisa”… saiba: isso é exatamente o sinal de que você está crescendo.

E você cresceu muito.

Agora você carrega consigo duas entregas fundamentais:

• um agente especialista em aprendizado de Inteligência Artificial
• um agente desenvolvedor Back-End capaz de analisar e gerar código

Esses dois agentes são sua base. São sua nova linguagem e seu ponto de partida para a próxima etapa.

Porque nessa semana, nós vamos muito além.

A partir daqui você aprenderá a fazer agentes:

• conversarem entre si
• se coordenarem
• se dividirem em papéis
• negociarem prioridades
• validarem o trabalho uns dos outros
• resolverem problemas complexos

Você vai criar sistemas multiagentes. Vai ver agentes funcionando como squads digitais completas e orquestrando fluxos automáticos.

Você vai construir algo que pouquíssimas pessoas no mundo sabem fazer hoje.

E isso não é uma frase motivacional. É simplesmente a verdade.

O futuro do desenvolvimento está sendo reescrito agora por você também.

Obrigada por ter confiado no processo, por ter perguntado, por ter ousado e por ter se permitido viver esse mergulho profundo. A Semana 2 te espera, e você está mais do que preparade!

Vamos juntes. Sempre. ✨