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.
Every week builds on the last. By week 5, you're not finishing a course, you're finishing a system.
Agents
Declared, configured, and published to the registry so the rest of the network can find and call them.
Brokers
AI-driven orchestration: the broker decides which agents and tools come into play for a given request.
Workflow Agents
Predefined steps, guaranteed execution path. For the flows where “the model decided” is not an acceptable answer.
Agent Script
All of it declared as a graph in .agent files, AI-powered nodes sitting next to deterministic ones.
AI Foundations Through the API Lens
The whole AI world, anchored in APIs you already understand. LLM as an API, structured output, choosing models. Function calling as the bridge between the model and your code. What an agent harness is and what an agentic environment looks like. Workflow vs agentic agents, and the question you'll answer all course long: what do you hand to the model, and what do you pin down in code. Conversation and context. How agents talk to each other, intro to the A2A protocol (spec version 1.0).
MCP & the Tool Layer
(from scratch)
The foundation Agent Fabric stands on. Model Context Protocol vs your own implementation; STDIO vs Streamable HTTP. You build an MCP server from scratch (spec-driven), then a second one via MCP Bridge, exposing existing APIs as tools. Security and privacy: authorization, permissions, prompt injection.
MuleSoft Agent Fabric I:
Discover & Govern
Get visibility and control before anything ships. Discover: Agent Registry, Agent Scanners, Public MCP Servers. Govern: Omni Gateway, AI / LLM Gateway, Trusted Agent Identity. You stand up an LLM Gateway, monitor token usage, control cost, add policies and protections, and govern your discovered assets through Omni Gateway.
We also cover the part nobody warns you about: how Mule credits pricing shapes your design.
MuleSoft Agent Fabric II:
Orchestrate with Agent Script
Agent Network 2.0 changed how orchestration is written, and this is the week you learn it. You declare a broker as a graph of nodes, edges, and triggers in .agent files, and read it on the visual canvas next to the code.
The core idea is guided determinism: probabilistic nodes where you genuinely need judgment (severity classification, intent recognition), deterministic nodes everywhere the execution path must be guaranteed. You also organise a real project, a /brokers directory, the agent-network.yaml registry, context definitions, and wire agents together over A2A Protocol 1.0. Then Observe: Agent Visualizer and Monitoring, so you can see what the network actually did.
Production, DevOps & Client Readiness
Deliverable: a production-ready project + automated deployment pipeline + a client agentic-transformation plan + verified Forge credential.
Put it all together into a production-ready agentic solution. Lots of broker-building that grows your skill set. Production realities: cost, security, privacy, monitoring.
You also automate the boring-but-critical part, DevOps for agentic workloads: building, publishing, and deploying agent networks through the Anypoint CLI plugin in a CI/CD pipeline, so the whole thing is repeatable, not a one-off you hand-built. And the part that pays off your career: how to lead an agentic transformation at a client with MuleSoft, mapping processes, phases, risks.
We also use MuleSoft Vibes to draft broker graphs from natural-language prompts, and then do the thing the prompt can't do for you: read the generated graph and decide what's actually safe to ship.
1× per week
Every week: 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
~3 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, post-Dreamforce, first cohort.
One cohort. One price.
No subscriptions.
Early Bird pricing. When the seats are gone, this price is gone.
- Everything in Regular
- Founding early-bird price
- Private cohort channel
- Forge credential on completion
Full price — opens once the Early Bird seats are gone.
- 5-week cohort
- Self-paced daily assignments
- Weekly live sessions
- Community channel
- 12-month material access
- Forge credential
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%
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.
Need help? Contact us at contact@integrationtrails.io
Before you ask
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.