IBM at WeAreDevelopers World Congress North America

Building an AI agent is easy. Making multiple agents collaborate safely, predictably and efficiently in a real application is the harder engineering challenge. 

In this session, you will follow an incident management case study built with IBM Bob. A live demo will show specialized agents triaging an incident, assessing business impact, planning a resolution, invoking tools and coordinating decisions through a supervisor. You will see how human approval protects critical actions and how distributed tracing makes agent behavior, tool calls, latency and failures visible. 

We will also demonstrate how IBM Bob uses a concise project context file to understand architecture, follow team conventions, generate consistent code and avoid generating APIs that do not exist. Along the way, we will examine where agent workflows commonly break, how to choose between sequential, parallel and supervisor-based coordination and how to control context and token usage without sacrificing quality. 

Key takeaways 
 1. Design reliable workflows involving multiple specialized AI agents. 
 2. Select sequential, parallel or supervisor coordination for each use case. 
 3. Apply human approval and tracing to make agent decisions safer and more observable. 
 4. Use IBM Bob with concise project context to produce consistent, governed code. 

You will leave with reusable design patterns, practical governance tips and a clear path for turning an agent prototype into a system that operations teams can understand, test and trust.

Speaker: Daniel Oh, Java Champion, STSM and Senior Principal Developer Advocate, Red Hat and IBM

As organizations scale their Kubernetes footprint, the “Day 2” reality of GitOps becomes clear: static thresholds are brittle. Standard canary rollouts rely on fixed Prometheus queries (for example, error rate < 1%), but these rules lack the context to distinguish between a minor transient blip and a systemic failure.

For platform engineers, this approach results in alert fatigue and manual promotion gates that slow down the delivery pipeline. In 2026, we are moving from static automation to reasoning platforms. 

This session explores how to evolve your delivery infrastructure into an intelligent system that doesn’t just follow rules, but reasons through data. We will demonstrate how to wrap Argo CD rollouts with an agentic reasoning layer capable of cross-referencing metrics, logs and distributed traces to make autonomous go/no-go decisions.

We will trigger a canary deployment that passes basic health checks but introduces a silent failure (for example, a cache hit-rate drop causing downstream latency). You will see the reasoning platform detect the anomaly, pause the rollout, “investigate” the root cause and present a natural-language justification for the automated rollback.

Speaker: Daniel Oh, Java Champion, STSM and Senior Principal Developer Advocate, Red Hat and IBM

Here’s a question: would you build a REST API and make users guess the request and response formats? Doing so opens a Pandora’s box. 

• What’s the domain model? 
• Name the operation… POST? GET? PUT? PATCH? 
• What does this error code even mean? 
• What documentation is accurate and relevant?

Imagine the complex, repetitive logic every consuming system would need to implement to make sense of it all. 

In a distributed, asynchronous system, these problems are magnified. Apache Kafka’s flexibility—messages as simple bytes—is a huge strength, but it’s also a major risk. While your event streams likely consist of some structured data (maybe JSON strings), enforcing structure, managing evolution and basic validations aren’t a hard requirement. This approach leaves consumer applications to perform this preprocessing for every event, even if that event has no business value.

In this session, we’ll define data contracts and how to enforce them at the source—the applications that produce events. We’ll cover the practice of using a schema registry that supports formats such as Apache Avro and Google Protobuf to design events in the terminology of our business domain. Because data structures change over time, let’s discuss safe schema evolution practices.

Then, we’ll use these contracts with schema registry-aware producer and consumer code. We’ll end our time by looking at how smart CI/CD pipelines and build-time checks can add an extra layer of defense against the costly problem of data poisoning.

It’s time to stop guessing and start governing. Join us to learn how to move validation upstream and transform your event streams into high-quality, discoverable data products. You’ll walk away with a practical blueprint for enforcing schema integrity and automating evolution—ensuring your data streams are a trusted asset.

Speaker: Sandon Jacobs, Senior Developer Advocate

Agentic AI-assisted engineering tools promise cleaner code, faster development and fewer late-night debugging sessions. But do they truly deliver?

In this live showdown, Viktor and Baruch will each use different AI coding tools, including IDEs and CLI agents (we’d name them, but things move fast in this space). They will use these tools to develop a non-trivial IoT application, from initial setup to testing and debugging, all live on stage.

Will the IoT bulb turn on by the end of the session and which tool will make it happen? You don’t know, we don’t know, but we’ll find out together, live on stage.

You, the audience, decide which tool best supports quality and productivity and which just adds noise instead of useful code. Bring your skepticism, cast your vote and get ready for surprises.

Speaker: Viktor Gamov, Principal Developer Advocate, Confluent