Salesforce MuleSoft · 2025-10-15 · Technical PMM
Shipped Agent Fabric demos and keynote scripts in two weeks while the product was still being built
Built A2A agents deployed on AWS and GCP, MCP servers, and a live multi-agent orchestration demo on a two-week timeline as the product shipped around me. Simultaneously wrote keynote demo scripts and kept three speakers current as capabilities changed daily.
Live at keynote. Zero demo failures.
Context
Agent Fabric was being built at the same time I was building the demos. There was no stable product to reference. I had to learn A2A agent architecture from scratch, deploy agents across AWS and GCP, build MCP servers, and understand agent orchestration patterns on a two-week timeline. On top of the technical build, I was writing keynote demo scripts and syncing with three speakers while the product APIs and capabilities changed every day.
What I did
Built A2A agents and deployed them to both AWS and GCP. Built MCP servers and wired them into a multi-agent network. Learned agent orchestration intricacies in real time as the product was being finalized. Wrote keynote demo scripts from scratch. Coordinated with three speakers across the two-week sprint, pushing updated scripts each time the product shifted. Managed the full production process alongside all of it.
Impact
Demos ran live at the keynote with no failures. Built the technical foundation that became the reference demo environment for Agent Fabric.
Artifacts
Watch the keynote
Context
Agent Fabric was being built at the same time I was building the demos for it.
There was no stable product to reference. No finalized API contracts. No confirmed feature set. The team was shipping daily and I was building on top of whatever existed that morning.
I had two weeks.
What I had to learn from scratch
A2A agents on AWS and GCP. I had not built A2A agents before this project. I learned the Strands framework, deployed agents to Amazon Bedrock AgentCore, and built a parallel deployment on GCP. Both had to work. The keynote needed to show cross-cloud agent interoperability.
MCP servers. Built MCP servers with Anypoint Code Builder to sit between the agents and Agent Fabric. Had to understand how the protocol handled tool registration, context passing, and what happened when a tool call failed mid-orchestration.
Agent orchestration. The intricacies are not in the docs. What happens when an agent times out? How does the orchestrator handle partial tool results? What does Agent Fabric's governance layer do when it intercepts a call it doesn't recognize? I learned all of this by building into failure and working backward.
The keynote layer on top
While the technical build was running, I was also writing the keynote demo scripts.
Three speakers. Each with a different section of the demo. Each needed their own version of the script updated every time the product changed, which was every day.
The challenge was not just keeping the scripts accurate. It was keeping three people confident in a demo that was still being built under them. That meant clear change logs, fast turnaround on revisions, and being honest about what was locked versus still in flux.
What made it work
The technical build and the script work fed each other. Understanding how the orchestration actually worked made the scripts more accurate. Writing the scripts forced me to identify gaps in the demo flow before they became problems on stage.
I also made a decision early: build for failure first. Every demo path had a fallback. Every agent call had a timeout handler. The keynote was not the place to discover edge cases.
What I would do differently
Start the speaker coordination earlier. The last three days were heavier than they needed to be because script updates were competing with final demo testing. Those should have been two separate tracks with clearer handoff points.