Agentforce 2.0, MCP e o Desenvolvedor Solo: Como a IA Está Reescrevendo o Desenvolvimento no Ecossistema Salesforce

Do TDX 2026 ao Google I/O: a convergência de Apex como ferramentas MCP, React nativo no Agentforce 360, e o surgimento do “llms.txt” criam um novo paradigma onde um único desenvolvedor orquestra agentes que antes exigiam equipes inteiras. 

O Ponto de Inflexão Chegou

Em maio de 2026, duas conferências definiram o novo normal para desenvolvedores Salesforce. No TDX 2026 (TrailheadDX), a Salesforce revelou o Agentforce 2.0, o Salesforce Multi-Framework e o Agentforce Vibes — transformando a plataforma de um CRM configurável em uma camada de execução autônoma para agentes de IA. Semanas depois, no Google I/O 2026, o anúncio do Firebase Agent Skills e do Android Studio Agent Mode completou o quadro: a pilha completa — frontend, backend, mobile, dados, IA — agora roda com um desenvolvedor no comando e uma frota de agentes executando.

Não é hype. É arquitetura.

O artigo “The Solo Developer Who Ships What Entire Teams Once Built” (Dev.to, 31/05/2026) captura essa mudança com precisão cirúrgica: “Dois anos atrás, entregar um produto que tocava automação de CRM, app mobile, frontend web em tempo real e backend na nuvem exigia pelo menos quatro especialistas. Hoje, um desenvolvedor com a stack certa faz tudo — não trabalhando mais, mas trabalhando com agentes.”

Este artigo desmonta as peças técnicas dessa revolução: MCP no Apex, React no Salesforce, Geração de código via linguagem natural, Observabilidade de agentes e o problema invisível que ninguém comenta — o conhecimento stale dos LLMs — e sua solução emergente: o padrão llms.txt.

1. Agentforce 2.0: Sua Org Agora É um Endpoint de IA

A mudança mais profunda do Agentforce 2.0 não está na UI — está na superfície de exposição. Como explica o artigo do Dev.to (31/05):

“Salesforce Agentforce 2.0 transformou o que era um CRM em uma camada de execução autônoma. Métodos Apex agora podem ser expostos como ferramentas MCP (Model Context Protocol), o que significa que agentes de IA como Claude ou Cursor podem descobrir e invocar sua lógica de negócio diretamente.”

O que isso significa na prática?

Antes: Você escrevia Apex, expunha via REST/Apex REST, documentava no Swagger, testava, publicava no AppExchange ou mantinha interno. O consumo exigia integração manual.

Agora: Você anota o método Apex com @InvocableMethod (ou usa a nova sintaxe de Hosted MCP Tools), e ele aparece automaticamente no catálogo de ferramentas disponíveis para qualquer agente compatível com MCP — seja o Claude Code, o Cursor, o GitHub Copilot ou um agente customizado.

// Exemplo: Expondo lógica de negócio como ferramenta MCP
public with sharing class AccountService {
    
    @InvocableMethod(label='Atualizar Indústria nos Contatos Filhos'
                     description='Quando a Industry da Account muda, propaga para todos Contatos filhos')
    public static void propagateIndustry(List<AccountIndustryChange> requests) {
        List<AccountIndustryChange> validRequests = new List<AccountIndustryChange>();
        Set<Id> accountIds = new Set<Id>();
        
        for (AccountIndustryChange req : requests) {
            if (req.accountId != null && req.newIndustry != null) {
                validRequests.add(req);
                accountIds.add(req.accountId);
            }
        }
        
        if (validRequests.isEmpty()) return;
        
        // Bulkified query - padrão moderno
        Map<Id, Account> accounts = new Map<Id, Account>([
            SELECT Id, Industry, (SELECT Id, Industry FROM Contacts) 
            FROM Account WHERE Id IN :accountIds
        ]);
        
        List<Contact> contactsToUpdate = new List<Contact>();
        for (AccountIndustryChange req : validRequests) {
            Account acc = accounts.get(req.accountId);
            if (acc != null && acc.Contacts != null) {
                for (Contact c : acc.Contacts) {
                    c.Industry = req.newIndustry;
                    contactsToUpdate.add(c);
                }
            }
        }
        
        // DML com AccessLevel.USER_MODE (Summer '24+) - substitui WITH SECURITY_ENFORCED
        if (!contactsToUpdate.isEmpty()) {
            Database.update(contactsToUpdate, Database.UpdateOptions.USER_MODE);
        }
    }
    
    public class AccountIndustryChange {
        @InvocableVariable(label='Account ID' required=true)
        public Id accountId;
        
        @InvocableVariable(label='Nova Industry' required=true)
        public String newIndustry;
    }
}

Este código — seguro, bulkificado, usando USER_MODE (não o deprecated WITH SECURITY_ENFORCED) — torna-se instantaneamente uma ferramenta chamável por um agente externo. O agente não precisa saber SOQL, não precisa saber Apex. Ele só precisa saber: “existe uma ferramenta chamada ‘Atualizar Indústria nos Contatos Filhos'”.

Fontes oficiais que confirmam:

• “Expose Custom Apex as a Hosted MCP Tool for Agents” (Salesforce Developers Blog, 13/05/2026) — Mohith Srivastava
• “Connect Claude with Salesforce Hosted MCP Servers” (Salesforce Developers Blog, 26/05/2026) — Philippe Ozil
• “The MCP Server for Marketing Cloud Engagement is Now GA” (Salesforce Developers Blog, 02/06/2026) — Spinninti & Frampton

2. MCP (Model Context Protocol): O USB-C dos Agentes

O MCP, padronizado pela Anthropic e adotado pela Salesforce, OpenAI, Microsoft e Google, resolve o problema da descoberta e invocação dinâmica de ferramentas. Pense nele como um “USB-C para IA”: um protocolo único que permite que qualquer agente descubra, entenda e invoque qualquer (capability) exposta — seja uma query SQL, uma API REST, uma função Apex ou uma ação no Slack.

No ecossistema Salesforce, três camadas MCP coexistem:

O artigo “Connect Claude with Salesforce Hosted MCP Servers” (26/05/2026) demonstra o fluxo completo: configurar o Connected App → habilitar MCP → o Claude Code descobre as ferramentas → invoca direto do terminal. Zero código de integração. Zero middleware.

3. Salesforce Multi-Framework: React Nativo no Agentforce 360

Anunciado no TDX 2026, o Salesforce Multi-Framework (antes conhecido como “Headless 360” ou “React on Salesforce”) elimina a necessidade de escolher entre LWC e frameworks modernos. Agora, React roda nativamente na plataforma.

O que muda para o desenvolvedor:

O artigo “What Salesforce Headless 360 Means For Developers” (21/05/2026) — René Winkelmeyer — explica: “Headless 360 expõe toda capacidade do Salesforce como API, ferramenta MCP ou comando CLI. Sua expertise de plataforma importa mais em um mundo agente.”

Exemplo: Componente React consumindo Apex via GraphQL

// src/components/AccountIndustryPropagator.tsx
import { useMutation, gql } from '@salesforce/graphql';
import { useState } from 'react';

const PROPAGATE_INDUSTRY = gql`
  mutation PropagateIndustry($accountId: ID!, $newIndustry: String!) {
    propagateIndustry(accountId: $accountId, newIndustry: $newIndustry) {
      success
      contactsUpdated
      errors
    }
  }
`;

export function AccountIndustryPropagator({ accountId }: { accountId: string }) {
  const [newIndustry, setNewIndustry] = useState('');
  const [propagate, { loading, error, data }] = useMutation(PROPAGATE_INDUSTRY);
  
  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    const result = await propagate({ 
      variables: { accountId, newIndustry } 
    });
    // Feedback visual, toast, etc.
  };
  
  return (
    <form onSubmit={handleSubmit} className="space-y-4 p-4 bg-white rounded-lg shadow">
      <label className="block text-sm font-medium text-gray-700">
        Nova Industry
        <input
          type="text"
          value={newIndustry}
          onChange={(e) => setNewIndustry(e.target.value)}
          className="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500"
          required
        />
      </label>
      <button 
        type="submit" 
        disabled={loading || !newIndustry}
        className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
      >
        {loading ? 'Propagando...' : 'Propagar para Contatos'}
      </button>
      {data && <div className="text-green-600 text-sm">
        ✅ {data.propagateIndustry.contactsUpdated} contatos atualizados
      </div>}
      {error && <div className="text-red-600 text-sm">❌ {error.message}</div>}
    </form>
  );
}

Sem @wire, sem lightning/uiRecordApi, sem NavigationMixin. Apenas React padrão, GraphQL padrão, hooks padrão. O desenvolvedor React não reaprende a plataforma — ele estende seu conhecimento existente para o ecossistema Salesforce.

4. Agentforce Vibes: Geração de Código via Linguagem Natural

O Agentforce Vibes (anunciado no TDX 2026) é talvez a ferramenta mais impressionante para o desenvolvedor solo. A partir de uma descrição em linguagem natural, ele gera:

1. Código React (componentes, hooks, tipos TypeScript)
2. Metadata Salesforce (Custom Objects, Fields, Permissions, Flows)
3. Queries GraphQL (types, queries, mutations)
4. Testes (Vitest + React Testing Library)

Exemplo real (baseado na demo do TDX):

Prompt: “Crie uma tela para o gerente de vendas ver todas as Opportunities do seu time, filtrar por stage, e ao clicar em uma, abrir um modal com detalhes e ações: ‘Avançar Stage’, ‘Adicionar Nota’, ‘Agendar Follow-up’.”

Output do Agentforce Vibes:

• OpportunityDashboard.tsx — Table com TanStack Table, filtros, paginação
• OpportunityModal.tsx — Modal com React Hook Form + Zod validation
• useOpportunities.ts — Hook com useQuery (GraphQL) + useMutation para ações
• opportunity.graphql — Query getTeamOpportunities + Mutations advanceStage, addNote, scheduleFollowUp
• Opportunity__c metadata — Custom fields para FollowUpDate__c, ManagerNotes__c
• OpportunityDashboard.test.tsx — Testes de integração com MSW mockando GraphQL

Tempo estimado manual: 2–3 dias (dev full-stack + admin Salesforce).
Tempo com Agentforce Vibes: 15–30 minutos + revisão humana.

Isso não substitui o desenvolvedor — elimina o boilerplate e deixa o humano focar no que importa: arquitetura, regras de negócio, edge cases, experiência do usuário.

5. O Problema Invisível: LLMs Escrevem Apex Deprecado — E a Solução llms.txt

Aqui está o segredo que ninguém conta nas keynotes: os melhores modelos de código (Claude Opus 4, GPT-4o, Copilot) ainda escrevem Apex de 2022.

O artigo “I built an llms.txt for Salesforce — so AI stops writing deprecated Apex” (Dev.to, 01/06/2026) — PesetasMasta — expõe o problema com dados concretos:

“Salesforce lança três releases por ano. LLMs são treinados em dados de 6–18 meses atrás. Resultado: código que parece certo e compila, mas usa padrões de dois ou três releases atrás. E a parte cruel: as coisas que mais mudaram — padrões de segurança e versões de API — são exatamente as que os modelos erram.”

Exemplos de código que LLMs ainda geram (e o correto):

A solução: llms.txt + sf-llms-context

O padrão llms.txt (emergente, adotado por Anthropic, OpenAI, Cursor) é um arquivo Markdown na raiz do projeto/repositório que diz ao agente: “Aqui está a verdade atual. Ignore seu treinamento.”

O projeto sf-llms-context (GitHub: pesetasmasta/sf-llms-context) implementa isso para Salesforce:

sf-llms-context/
├── llms.txt                    # Ponto de entrada para agentes
├── apex/
│   ├── security-patterns.md    # USER_MODE vs WITH SECURITY_ENFORCED
│   ├── dml-patterns.md         # Database.* com AccessLevel
│   ├── testing-patterns.md     # Assert class, não System.assert*
│   └── governor-limits.md      # Limites verificados contra v67.0
├── lwc/
│   ├── wire-adapters.md        # lightning/ui*Api atuais
│   └── testing.md              # UTAM, Playwright patterns
├── flow/
│   └── best-practices.md       # Substitui WF/PB
└── api-versions.md             # Versão atual: 67.0

Princípios de design (do artigo):

1. AI-first, não human-first — Cada arquivo abre com instrução ao agente, depois conteúdo denso.
2. Mostra errado E certo — Padrão deprecated ao lado do atual, com motivo (governor limit / segurança / deprecação).
3. Token-eficiente — Brevidade é feature. Cada padrão = poucos centenas de tokens.
4. Verificado, não adivinhado — Todo número de governor limit e versão de API checado contra docs oficiais Summer ’26.

Resultado prático (teste controlado do autor):

Três modelos — Opus 4.8, Sonnet 4.6, ChatGPT free — mesma user story: “Quando Industry da Account muda, copia para campo em todo Contact filho. Inclua testes.”

Conclusão: O contexto muda a saída. Não é mágica — é engenharia de conhecimento.

6. Observabilidade: AgentLens e o Debug Visual de Agentes

Quando agentes executam lógica de negócio em produção, você precisa ver o que eles estão fazendo. O AgentLens (Salesforce Developers Blog, 13/05/2026 — Mohith Srivastava) traz visualizações interativas para o Agentforce:

• Trace de execução — Cada passo do agente: raciocínio → seleção de ferramenta → invocação → resultado
• Timeline de latência — Onde o tempo é gasto (LLM vs Apex vs Data Cloud vs externo)
• Grafo de dependências — Quais ferramentas MCP foram chamadas, em que ordem, com que payloads
• Replay — Reexecutar uma conversa passada com o mesmo contexto para debug

Isso transforma o Agentforce de “caixa preta” em sistema observável — requisito para enterprise.

// Exemplo de trace AgentLens (simplificado)
{
  "sessionId": "agentforce-session-20260605-001",
  "steps": [
    {
      "step": 1,
      "type": "reasoning",
      "content": "User asked to propagate Industry change. Need to identify child Contacts and update.",
      "durationMs": 450
    },
    {
      "step": 2,
      "type": "tool_selection",
      "tool": "AccountService.propagateIndustry",
      "confidence": 0.94,
      "durationMs": 120
    },
    {
      "step": 3,
      "type": "tool_invocation",
      "tool": "AccountService.propagateIndustry",
      "payload": { "accountId": "001...", "newIndustry": "Technology" },
      "durationMs": 890
    },
    {
      "step": 4,
      "type": "tool_result",
      "result": { "success": true, "contactsUpdated": 47, "errors": [] },
      "durationMs": 50
    }
  ],
  "totalDurationMs": 1510
}

7. Slack Agentic OS: O Agente no Onde o Trabalho Acontece

O anúncio do Slack Agentic OS (Slack Blog, Maio/2026) e o artigo “Slackbot Just Became Your Ultimate Teammate” completam a pilha: o agente vive onde os humanos trabalham.

• Slackbot agora roteia agentes de terceiros, expõe contexto de negócio e executa tarefas cross-app
• 30 novos recursos de IA no Slack (TechCrunch, 31/03/2026)
• Integração nativa com Agentforce — o agente Salesforce aparece no Slack, e vice-versa

Para o desenvolvedor solo: você não constrói UI de chat. Você expõe ferramentas MCP. O Slack (e o Agentforce, e o Claude, e o Cursor) fornecem a interface conversacional.

8. Impacto Estratégico: Para Empresas e Desenvolvedores

Para CTOs / VPs de Engenharia:

Para Desenvolvedores Individuais:

1. A barreira de entrada caiu — Saber React + TypeScript + conceitos de CRM = produtivo em Salesforce em dias.
2. O teto subiu — Um dev solo pode entregar escopo de equipe enterprise.
3. A habilidade crítica mudou — De “saber sintaxe Apex/LWC” para “saber orquestrar agentes, validar saída, arquitetar guardrails”.

9. Roteiro Prático: Como Começar Hoje

Conclusão: O Futuro Já Está em Produção

A convergência de Agentforce 2.0 + MCP + Multi-Framework + llms.txt não é uma promessa de roadmap — é código rodando em orgs reais hoje.

O desenvolvedor que entender essa pilha, adotar o llms.txt como prática padrão, e aprender a orquestrar agentes em vez de apenas escrever código não estará “preparado para o futuro”. Ele estará definindo o futuro.

Clone o sf-llms-context, adicione o llms.txt ao seu repo Salesforce hoje. Exponha seu primeiro método Apex como ferramenta MCP. Teste no Claude Code. Meça a diferença.

Compartilhe seus resultados nos comentários com a comunidade OnlySalesforce está construindo esse conhecimento junto.

Próximo artigo: “Construindo o Primeiro Agente Enterprise com Agentforce Vibes: Do Prompt à Produção em 30 Minutos” — fique ligado.

Referências e Fontes

1. Salesforce Developers Blog — “Expose Custom Apex as a Hosted MCP Tool for Agents” (13/05/2026) — Mohith Srivastava
2. Salesforce Developers Blog — “Connect Claude with Salesforce Hosted MCP Servers” (26/05/2026) — Philippe Ozil
3. Salesforce Developers Blog — “The MCP Server for Marketing Cloud Engagement is Now GA” (02/06/2026) — Spinninti & Frampton
4. Salesforce Developers Blog — “What Salesforce Headless 360 Means For Developers” (21/05/2026) — René Winkelmeyer
5. Salesforce Developers Blog — “Use Custom Lightning Types in Agent Script for Rich Agent UI” (19/05/2026) — Mohith Srivastava & Parvinder Singh
6. Salesforce Developers Blog — “The New Agentforce Metadata and Development Lifecycle” (14/05/2026) — Alba Rivas & Shreyas Ramesh
7. Salesforce Developers Blog — “AgentLens: Debug Agentforce with Interactive Visualizations” (13/05/2026) — Mohith Srivastava
8. Salesforce Developers Blog — “Simplify Your SOQL Queries Using SOQL FORMULA() in WHERE” (02/06/2026) — Dikshita Patel
9. Dev.to — “I built an llms.txt for Salesforce — so AI stops writing deprecated Apex” (01/06/2026) — PesetasMasta
10. Dev.to — “The Solo Developer Who Ships What Entire Teams Once Built” (31/05/2026) — Debajyoti Ghosh
11. TechCrunch — “Salesforce is crowdsourcing its AI roadmap — with customers” (30/04/2026) — Rebecca Szkutak
12. TechCrunch — “Salesforce announces an AI-heavy makeover for Slack, with 30 new features” (31/03/2026) — Lucas Ropek
13. Slack Blog — “Introducing the Agentic OS: How Slack Is Reimagining Work for the AI Era” (Maio/2026)
14. Slack Blog — “Slackbot Just Became Your Ultimate Teammate in the New Interface for Work” (Maio/2026)
15. VentureBeat — “The AI agent bottleneck isn’t model performance — it’s permissions” (29/05/2026) — Emilia David
16. GitHub — pesetasmasta/sf-llms-context — Repositório do projeto llms.txt para Salesforce