Training course · AI Agent Development · Salesforce Development

AI Agent Development for Salesforce Developers

Build AI agents professionally: architectures, tool use, agent SDKs, LangGraph, memory, evals, guardrails and deployment.

Duration
2 days (14 hrs)
Format
Online or on-site
Language
German or English
Participants
open dates or exclusive for your team
Certificate
Certificate of attendance

Overview

“AI Agent Development for Salesforce Developers” is a hands-on course for roles such as Salesforce developers working with Apex and Lightning Web Components, Salesforce architects and technical leads and Salesforce administrators who also develop. Rather than learning AI Agent Development in the abstract, you work on tasks from your daily routine – with examples, exercises and templates from Salesforce Development.

AI agents go beyond conventional chatbots: they break tasks down, call tools and APIs, evaluate the results and keep iterating until a goal is met. In this two-day course you learn to build such systems so that they work reliably, transparently and safely in day-to-day business. You compare architectural patterns ranging from simple workflows through the agent loop to multi-agent systems, and you implement them hands-on with the Claude Agent SDK, the OpenAI Agents SDK and LangGraph.

The focus is not on a quick demo but on the path to production. You design tool interfaces and context deliberately, connect tools via the Model Context Protocol, plan short-term and long-term memory and build evaluations that surface regressions early. On top of that come guardrails against prompt injection and harmful actions, human-in-the-loop approvals, tracing, cost control and deployment. By the end you can judge when an agent is worthwhile, when a deterministic workflow is enough and which framework fits your project.

Salesforce orgs grow over the years into complex platforms of Apex classes, triggers, flows, Lightning Web Components and integrations. AI coding assistants and agents help Salesforce developers write Apex and LWC faster, generate test classes with meaningful coverage, account for governor limits early and move sprawling trigger logic into clean frameworks. They support SOQL optimisation, metadata analysis and the migration from Process Builder and workflow rules to Flow. Because Salesforce code must be multi-tenant aware, bulkified and security-conscious, AI needs targeted context and clear rules. In this course you learn to combine AI tools with Salesforce CLI, scratch orgs and your DevOps pipeline while reliably respecting sharing rules, field-level security and platform limits.

The course is delivered live – either online in a virtual classroom or on-site in our training rooms in Munich, Salzburg, Berlin, Augsburg, Hanover, Bremen, Stuttgart and Kaiserslautern. We can also run it exclusively for your team.

Who is this course for?

  • Salesforce developers working with Apex and Lightning Web Components
  • Salesforce architects and technical leads
  • Salesforce administrators who also develop
  • Integration developers building Salesforce interfaces
  • Salesforce consultancies and partner teams

Typical challenges we address

  • Governor limits, bulkification and trigger recursion cause hard-to-reproduce errors
  • Mandatory test coverage consumes a lot of time writing test classes
  • Mature orgs with overlapping triggers, flows and processes and no documentation
  • Security requirements such as CRUD and FLS checks and sharing are often forgotten in code

What you will be able to do

  • You choose the right pattern for a task, from a fixed workflow to an autonomous agent.
  • You design tools and context so that agents work reliably and cost-effectively.
  • You implement agents with the Claude Agent SDK, the OpenAI Agents SDK or LangGraph.
  • You set up evaluations and tracing to measure quality and detect regressions.
  • Develop Apex and Lightning Web Components with AI support that are bulkified, secure and within limits.
  • Generate meaningful test classes and analyse org metadata systematically with AI agents.
  • Integrate AI tools with Salesforce CLI, scratch orgs and your deployment pipeline.

Course outline

Day 1

Module 1 Agent architectures and design patterns
  • Workflows versus agents: prompt chaining, routing, parallelisation, orchestrator-worker
  • The agent loop: plan, act, observe, reflect
  • Multi-agent systems, subagents and handoffs between agents
  • Criteria for choosing model, framework and level of autonomy
Module 2 Tool use and context engineering
  • Function calling and structured outputs with JSON Schema
  • Designing good tools: granularity, naming, error messages, idempotency
  • Connecting and reusing tools via MCP servers
  • Managing the context window: summarisation, compaction, retrieval and prompt caching
Module 3 Frameworks in practice
  • Claude Agent SDK: agent loop, tools, subagents, permissions and hooks
  • OpenAI Agents SDK: agents, handoffs, guardrails and tracing
  • LangGraph: stateful graphs, checkpointing and human-in-the-loop
  • Side-by-side comparison on the same task and criteria for choosing a framework
Module 4 Memory, evals and observability
  • Short-term and long-term memory, storage strategies and forgetting
  • Evaluation datasets, LLM-as-a-judge and task-based success metrics
  • Tracing tool calls, token usage and latency
  • Regression testing when prompts, models or tools change

Day 2

Module 5 Guardrails, security and deployment
  • Protecting against prompt injection, data exfiltration and over-privileged tools
  • Input and output checks, approval steps and sandboxing
  • Deploying as a service, asynchronous execution, retries and cost limits
  • Governance, audit logging and requirements under GDPR and the EU AI Act
Module 6 Practice lab: Salesforce Development
  • Writing bulkified Apex
  • Generating test classes
  • Building Lightning Web Components
  • Optimising SOQL and performance
  • Analysing org metadata
  • Preparing for security review
Module 7 Data protection, quality & transfer to daily work
  • Salesforce orgs hold customer and sales data: you learn to share only metadata and anonymised samples with AI services, protect credentials and connected app secrets, implement GDPR requirements for data retention and clarify licensing questions around generated code in AppExchange packages.
  • Ground rules for safe AI use in your team
  • Checking results: facts, sources, tests and the four-eyes principle
  • Personal action plan for the next 30 days
  • Open questions, outlook and resources for further learning

Practical scenarios from your field

Writing bulkified Apex

Generate trigger handlers, service classes and batch or queueable jobs that keep SOQL and DML out of loops, respect governor limits and apply patterns such as trigger frameworks consistently.

Generating test classes

Create meaningful Apex tests with test data factories, positive and negative cases, bulk scenarios and assertions that verify real logic rather than just coverage, including mocks for callouts.

Building Lightning Web Components

Develop LWC components with wire adapters, Apex controllers, Lightning Data Service and Jest tests, and migrate existing Aura components step by step. Accessibility and loading states are covered too.

Optimising SOQL and performance

Write selective queries, interpret Query Plan results, spot large data volume issues and propose alternatives such as custom indexes, skinny tables or asynchronous processing. This prevents timeouts as data grows.

Analysing org metadata

Evaluate retrieved metadata to document automations per object, dependencies between fields, flows and Apex, and unused components, and plan clean-up work. The result is finally up-to-date documentation.

Preparing for security review

Examine Apex and LWC for missing CRUD and FLS checks, SOQL injection, unsafe sharing settings and cross-site scripting, and implement fixes using user mode and stripInaccessible.

Possible hands-on projects

Automation map

A script that reads an org’s metadata and shows every trigger, flow and validation rule per object, including execution order, in one overview.

Test data factory generator

A tool that produces a reusable Apex factory from object and field definitions, with required fields and valid picklist values.

LWC dashboard component

A Lightning Web Component that aggregates an account’s key figures from several objects and displays them with filters and drill-down.

Prerequisites

Solid programming skills in Python or TypeScript, experience with REST APIs and some hands-on experience with LLM APIs or AI assistants. You already develop in Apex or Lightning Web Components and have a working knowledge of the Salesforce data model, governor limits and Salesforce CLI.

Technical requirements

A laptop with Python or Node.js, Git and a code editor, plus API access to at least one LLM provider such as Anthropic or OpenAI. Credentials for the exercises can be provided if needed.

Data protection & compliance

Salesforce orgs hold customer and sales data: you learn to share only metadata and anonymised samples with AI services, protect credentials and connected app secrets, implement GDPR requirements for data retention and clarify licensing questions around generated code in AppExchange packages.

Suggested dates

All dates are suggestions – your preferred date is always possible.

  • Tue, 24 November 2026 – Wed, 25 November 2026 Online Request
  • Tue, 1 December 2026 – Wed, 2 December 2026 Hanover Request
  • Thu, 17 December 2026 – Fri, 18 December 2026 Online Request
  • Thu, 21 January 2027 – Fri, 22 January 2027 Online Request
  • Thu, 28 January 2027 – Fri, 29 January 2027 Stuttgart Request
  • Tue, 9 February 2027 – Wed, 10 February 2027 Online Request

Frequently asked questions

Which agent framework should we use?

It depends on your model strategy, the level of control you need and your team’s skills. Vendor SDKs offer a lean start with tightly integrated features, while LangGraph gives you finer control over state and flow. In the course you solve the same task with several frameworks and derive clear selection criteria for your own project.

How do you stop an agent from taking wrong or dangerous actions?

With several layers of protection: narrowly scoped tools with minimal permissions, input and output validation, approval steps for critical actions, sandboxing and continuous evaluation. Prompt injection via external content is treated as a realistic threat. You practise these measures directly on your own agent.

Does every automation need an agent?

No. Many tasks are handled more reliably, cheaply and transparently by a fixed workflow of a few LLM calls. Agents pay off when the solution path cannot be planned in advance and the system must react flexibly to intermediate results. We train exactly this trade-off using practical examples.

How well do general-purpose AI assistants know Apex and Salesforce specifics?

Current models handle Apex syntax and common patterns well. Weaknesses show up around governor limits, bulkification and org-specific objects. With rule files covering your trigger framework, naming conventions and security standards, plus retrieved metadata as context, results become far more reliable. In the course you build exactly this context for your org.

Should an AI agent deploy straight into our Salesforce org?

We recommend letting agents work in scratch orgs or sandboxes and promoting changes to higher environments through version control and your deployment pipeline. That preserves reviews, test runs and approvals. Production orgs should be reachable by agents read-only at most, using a restricted user. You practise this way of working hands-on in the course.

How much does “AI Agent Development for Salesforce Developers” cost?

The course costs a flat €949 plus VAT per participant – whether online or on-site. This includes 2 training day(s) with a live trainer, course materials, a lab environment and a certificate of attendance.

Can I suggest my own date?

Yes. Our suggested dates are just a guide. In the request form you can always describe your preferred date or period in free text – we check availability and confirm within one working day.

Is the course online or on-site?

Both are possible: live online in a virtual classroom or on-site in Munich, Salzburg, Berlin, Augsburg, Hanover, Bremen, Stuttgart or Kaiserslautern. We can also run the course exclusively for your team.

More courses for Salesforce Developers

More AI Agent Development courses

All 30 AI Agent Development courses

AI Agent Development · MunichAI Agent Development · SalzburgAI Agent Development · BerlinAI Agent Development · AugsburgAI Agent Development · HanoverAI Agent Development · BremenAI Agent Development · StuttgartAI Agent Development · KaiserslauternAI Agent Development · Online