MuleSoft Agent Fabric.
Not just the demo. The production version.
AI specialists already build agents. But almost no one is doing it inside MuleSoft integration - under real governance, cost, and failure conditions. That's where the demand is going, and where the experts aren't yet.
Mule AI Forge is a 5-week cohort bootcamp where you build a production-ready AI integration on MuleSoft Agent Fabric - guided by a practitioner who has already shipped it, mistakes and all.
Agentic transformation is the new digital transformation.
Here's the good news: you already know more than you think. Agentic transformation is remarkably close to the digital transformation you've already lived through, the API era. The same problems come back, discovery, governance, orchestration, observability, only the actors are now agents and MCP instead of APIs. MuleSoft saw this early and built Agent Fabric on exactly that bridge.
And here's the part that compounds: AI keeps getting more expensive, and leaning on it blindly is a trap. The consultants who actually understand the stack use AI better, and cheaper. They know what to offload to a model, what to control, and where the costs quietly add up. Skill doesn't compete with AI; it multiplies it. Better knowledge means you ship more, faster, for less, and that's exactly what makes you more valuable.
Forge teaches the AI world through API analogies you already understand, and turns it into a career move. Five weeks. One cohort. You come out ready to lead an agentic transformation at a client before the market catches up.
Agentic skills are in high demand and short supply.
Forge puts you in the first wave, more employable, more valuable, ahead of peers.
AI is getting more expensive. Knowledge is the hedge.
The more you understand the stack, the cheaper and smarter you can run AI, skill multiplies the tool instead of paying for it blindly.
The first cohort owns the conversation.
The consultants who can say “I've shipped this in production” will own the conversation for the next two years.
You leave Forge with working projects,
not just notes.
The Core System
An enterprise-grade AI integration using MuleSoft Agent Fabric - an agent-driven system that processes business events, orchestrates actions across systems, handles failure gracefully, and runs within real cost and governance constraints. The orchestration is explicit and auditable: a graph you can read, not a black box you hope behaves.
The Deliverables
- A broker in Agent Script, its agents, and your MCP servers, deployed and tested
- Architecture decision record: what you built, why, what you'd change
- Production checklist: governance, error handling, cost control patterns
- A portfolio piece you can show clients and use in proposals
Agent Fabric in production is a different story.
The agent that worked perfectly in the sandbox
...and timed out under real API load because nobody designed for back-pressure. The retry logic made it worse.
The AI-generated orchestration flow
...that passed the code review and failed at the edge case nobody modeled. The agent didn't know what to do when the external system returned something unexpected. Knowing which steps to pin down as deterministic is a design decision, and the tool won't make it for you.
The demo that became a production promise
Your client saw the Dreamforce keynote. Now they want it in their environment. You have three weeks to figure out what “production-ready” actually means.
Forge is built to close that gap, before you meet it on a client project.
Five weeks.
From AI foundations to a production agentic solution.
25 days, 25 hands-on challenges. Every day ends with something you built and something you keep. By week 5, you're not finishing a course, you're walking away with a playbook.
No frontend. The interface is an API, a business event, or another agent over A2A.
Agents
Declared, configured, and published to the registry, triggered by an API, a business event, or another agent - never a chat window.
MCP Servers
The tool layer: servers built from scratch and existing APIs exposed through MCP Bridge, designed as tools a model can actually use.
Brokers
AI-driven orchestration: the broker decides which agents and tools come into play for a given request.
Agent Script
All of it declared as a graph in .agent files: probabilistic nodes next to deterministic ones and workflow agents, for paths that must be guaranteed.
Day-by-day breakdown: all 25 days, 75 lessons → Full Forge Curriculum
How an Agent Works, and How to Design It
Your agent runs on the platform on day 2. The model as an API dependency: contract, tokens, cost, latency, choosing a model. Your first Agent Network project, tested with Postman/curl; MuleSoft Vibes as assistant, not author. Scope and instruction as a contract, dynamic instructions, structured output wired into a Mule flow with an error path.
Then we open the black box: hand-written function calling and agent loop, plus the question you'll answer all course long: workflow or orchestration.
What an Agent Acts With,
and What It Sees
Why MCP exists (the M×N problem) and when it doesn't pay off. Tools and resources over Streamable HTTP. You build an MCP server from scratch, spec-driven, tested in Inspector/Playground. The context window as a budget, long-term memory as an MCP tool.
Agents triggered by events, progress reporting, human-in-the-loop. At scale: MCP Bridge, API design ≠ tool design, a hundred tools across five servers.
Before It Ships: Visibility,
Control & the Bill
The agent leaves your laptop: published, secured, costed. Discover: Agent Registry, agent card (a light first look at A2A), Scanners, Shadow AI. Govern: Omni Gateway, Trusted Agent Identity, default policies. Security: identity and permissions for MCP, prompt injection and tool poisoning - you red-team your own solution.
AI/LLM Gateway: vendor lock-in, PII masking, semantic routing, fallback. And the part nobody warns you about: how Mule credits pricing shapes your design - cost per transaction, optimised by ≥30%, budgets and alerts.
When One Agent Isn't Enough
Tool vs subagent vs second agent, with context isolation as the main criterion. Brokers, /brokers, agent-network.yaml. A2A Protocol 1.0 in depth: task lifecycle, contextId/taskId, long-running tasks, a non-MuleSoft agent wired into the network.
Agent Script: a broker as a graph of nodes, edges and triggers in .agent files, read on the visual canvas, drafted with Vibes and audited with a checklist. Guided determinism: probabilistic vs deterministic nodes, hybrid patterns. Context and memory across the network, traced in Agent Visualizer.
From Project to Client Deployment
Blueprint: a decision tree, not a layer diagram. When to use a plain integration, a workflow agent, or a broker - and when to tell the client AI is the wrong call for this process. A default solution skeleton and a one-page blueprint with your name on it.
DevOps for agentic workloads: building, publishing, and deploying agent networks through the Anypoint CLI plugin, per-environment configuration, a CI/CD pipeline with deterministic test gates (no model evaluation - we say plainly why, and where that topic lives), and a proven rollback.
Production and wrap-up: failure modes and controlled degradation, privacy and compliance, a production checklist, a runbook and alerts. Then the whole path on one diagram, everything you kept organised into a playbook, and a plan for Monday after the course.
Every Friday
Every Friday: a live Q&A session with Patryk. Open questions, community discussion, the edge cases that came up during that week's work. Not a lecture, a conversation.
How Forge actually fits into your week
~2 hours per lesson
Each lesson pairs a short read or video with a hands-on assignment, budget around 3 hours per lesson. Move through them at your own pace, what's fixed is the 80% completion bar for your certificate, not a daily clock.
Self-paced assignments, real deadline
Each assignment is graded, automatically or manually. Work through them on your own schedule, but complete at least 80% within the certification window (5 weeks, or up to 3 extra months) to earn your credential. This is a real bar, not a participation trophy.
One live session a week
Every week: 1–2 hours with Patryk. Q&A, community discussion, the week's edge cases. Not recorded and re-watched alone, attended live.
One cohort
You go through Mule AI Forge alongside other Integration Engineers solving the same scenarios. The community channel is active. The perspectives help.
Track your progress, and finish with proof
A clean dashboard shows your mission in real time: lessons cleared, assignments passed, the skills you're building, week by week. Finish the mission and it's capped with a certificate that confirms practical skills, something you can add to LinkedIn and share with clients, not a screenshot of a PDF.
Patryk Bandurski
The scenarios in Forge aren't invented. They're the architectural decisions that went wrong on real client projects, the Agent Fabric patterns that looked right and broke in production, and the governance questions that appeared only after deployment.
You get the judgment from someone who's already shipped this, and paid for the mistakes that you won't have to.
Forge is for consultants who are ready to build.
MuleSoft Developer
or Architect
You've shipped integrations. You've seen the Agent Fabric announcements. You want to be the person who can actually design and deliver it on a client project, not the one who watched the keynote and hoped nobody would ask.
Salesforce
Consultant
AI agents are moving into your territory. Your clients are asking questions you can't fully answer yet. You don't need to become a MuleSoft engineer. You need to understand what “production-ready” means when Agent Fabric is on the table.
Integration
Architect
You're the person who makes the call on architecture. AI agents are about to be part of the options on every enterprise table. You need to know when Agent Fabric is the right answer, and when it's a Dreamforce demo sold as a solution.
What you walk away with
1. You can design Agent Fabric solutions that survive production.
Not “I've seen the docs.” Not “I've done the tutorial.” You've built one, end to end, and you know what breaks and why.
2. You can evaluate AI-generated Agent Fabric code.
Every week in Forge includes AI critique work, including reading broker graphs generated by MuleSoft Vibes. By week 5, you know which patterns AI suggests that look right and which ones will fail under real load.
3. You have a portfolio piece, not just a certificate.
A working production-grade project. An architecture decision record. A deployment checklist. Something you can reference in a proposal or walk through in a technical interview.
4. You're part of the first cohort.
The consultants who get ahead of Agent Fabric knowledge now will be the ones setting direction when the rest of the market catches up. Forge credentialed, first cohort, starting 19 October 2026.
One cohort. One price.
No subscriptions.
This price has closed.
- Ship a working agent on Agent Fabric by the end
- 5-week cohort — recorded lessons, learn on your schedule
- Live Q&A to unblock you when you're stuck
- Daily hands-on assignments you actually deploy
- Private community channel with your cohort
- 12-month access to all course materials
- A verifiable Forge credential — earned by building
Local tax may be added at checkout, based on your billing country.
Full price. The cohort runs once a year.
- Ship a working agent on Agent Fabric by the end
- 5-week cohort — recorded lessons, learn on your schedule
- Live Q&A to unblock you when you're stuck
- Daily hands-on assignments you actually deploy
- Private community channel with your cohort
- 12-month access to all course materials
- A verifiable Forge credential — earned by building
Sending your team through Forge?
We offer volume pricing and a coordinated onboarding experience for groups.
- 3–5 seats: -10%
- 6–30 seats: -15%
- 30+ seats: -20%
One-time payment. No subscription.
You're covered by a 14-day money-back guarantee. If you complete less than 20% of Week 1 and decide the cohort isn't right for you, we'll issue a full refund.
Want the detail before you commit? Read the full Forge Curriculum.
Need help? Contact us at contact@integrationtrails.io
Before you ask
When does the cohort start?
Is there a detailed curriculum?
Do I need to know MuleSoft already?
Which version of Agent Fabric does this cover?
What if I fall behind?
Is this only for MuleSoft developers?
What happens after the 5 weeks?
Does it run again if I miss this cohort?
Where does the bootcamp actually happen?
Is there a refund policy?
The next cohort won't wait.
Forge runs once a year. Once the spots are gone, they're gone.
If you've read this far, you know if this is for you.