Uploaded July 2026 | Updated September 2026, 3 weeks ago
As AI agents move from single-agent workflows to multi-agent systems, debugging gets harder. Individual traces can show what happened inside one agent, but they often miss the handoffs, reasoning, retries, approvals, and failures that happen between agents.
In this Observe 2026 session, Ofer Mendelevitch, Head of Developer Relations at Band, explains how agent-to-agent communication works, why multi-agent systems need end-to-end observability, and what changes when agents built in different frameworks need to collaborate across systems, teams, or companies.
Ofer walks through Band’s “agentic mesh” concept: a communication layer for agents that works like chat rooms for AI agents. He also shows why traditional traces are not enough for multi-agent debugging, including clock drift, incomplete handoff visibility, hidden retries, and missing reasoning across agents.
The session closes with a demo of a billing workflow where multiple agents collaborate, introduce an error, and then become debuggable through shared messages, thoughts, tool calls, task events, and end-to-end traces.
Chapters:
00:00 Intro: Ofer Mendelevitch from Band
00:29 Agent-to-agent communication and multi-agent systems
01:09 The future of agent interactions
01:57 Band’s agentic mesh for cross-framework agents
02:42 Chat rooms for agents
03:31 Why single-agent tracing is not enough
04:19 Failure modes in multi-agent systems
05:05 The signals needed for multi-agent observability
05:57 From scattered traces to end-to-end visibility
06:36 Demo: Band agent chat rooms
07:14 Billing workflow with customer support, pricing, and collections agents
08:19 Capturing thoughts, tool calls, and handoffs
09:08 Debugging a multi-agent billing error
10:02 Why end-to-end observability matters
Subscribe to Arize for more talks on AI agents, LLM observability, multi-agent systems, evals, tracing, and production AI engineering.
🔗 Try Arize AX & Phoenix OSS: arize.com
🔔 Subscribe for weekly content on LLMs, agents, and evaluation: youtube.com/@arizeai?sub_confirmation=1
As AI agents move from single-agent workflows to multi-agent systems, debugging gets harder. Individual traces can show what happened inside one agent, but they often miss the handoffs, reasoning, retries, approvals, and failures that happen between agents.
In this Observe 2026 session, Ofer Mendelevitch, Head of Developer Relations at Band, explains how agent-to-agent communication works, why multi-agent systems need end-to-end observability, and what changes when agents built in different frameworks need to collaborate across systems, teams, or companies.
Ofer walks through Band’s “agentic mesh” concept: a communication layer for agents that works like chat rooms for AI agents. He also shows why traditional traces are not enough for multi-agent debugging, including clock drift, incomplete handoff visibility, hidden retries, and missing reasoning across agents.
The session closes with a demo of a billing workflow where multiple agents collaborate, introduce an error, and then become debuggable through shared messages, thoughts, tool calls, task events, and end-to-end traces.
Chapters:
00:00 Intro: Ofer Mendelevitch from Band
00:29 Agent-to-agent communication and multi-agent systems
01:09 The future of agent interactions
01:57 Band’s agentic mesh for cross-framework agents
02:42 Chat rooms for agents
03:31 Why single-agent tracing is not enough
04:19 Failure modes in multi-agent systems
05:05 The signals needed for multi-agent observability
05:57 From scattered traces to end-to-end visibility
06:36 Demo: Band agent chat rooms
07:14 Billing workflow with customer support, pricing, and collections agents
08:19 Capturing thoughts, tool calls, and handoffs
09:08 Debugging a multi-agent billing error
10:02 Why end-to-end observability matters
Subscribe to Arize for more talks on AI agents, LLM observability, multi-agent systems, evals, tracing, and production AI engineering.
🔗 Try Arize AX & Phoenix OSS: arize.com
🔔 Subscribe for weekly content on LLMs, agents, and evaluation: youtube.com/@arizeai?sub_confirmation=1









![When AI Can Write Code, What Are Software Engineers Worth? | Citadel
When AI can generate code in seconds, what still makes a software engineer valuable?
In this Arize:Observe session, Craig Owenby of Citadel explores how agentic coding tools are changing software engineering, and why the profession still requires far more than producing code.
Craig compares large language models to the printing press. The printing press replaced the manual work of copying books, but it did not replace authors. In the same way, AI coding agents can automate the mechanics of writing code without replacing the judgment, vision, empathy, and experience required to build useful software.
The session covers:
• Why “coder” and “software engineer” are increasingly different roles
• How tools like Claude Code, Codex, Copilot, and Cursor remove traditional barriers to building software
• What the printing press teaches us about AI-assisted development
• Why engineers should avoid competing with AI on raw code generation
• How Sears lost its advantage by competing with e-commerce on the wrong terms
• Why human experience, intuition, and empathy remain essential
• How constraints can improve product and engineering decisions
• Why shipping more features can increase volatility and reduce user trust
• How AI acts as leverage for strong and weak engineering decisions
• Why product direction and problem selection matter more as implementation gets easier
The central lesson: software engineering is not primarily about writing code. It is about deciding what should be built, understanding why it matters, and applying technology with judgment.
When everyone can code, engineers differentiate themselves through their standards, instincts, product sense, and ability to understand the people using what they build. :contentReference[oaicite:0]{index=0}
Chapters:
00:00 When everyone can code, what are engineers worth?
00:46 LLMs and the printing press
01:30 The limits that shaped software engineering
02:42 We finally live in a world where everyone can code
03:45 The existential question for experienced engineers
04:45 Coders versus software engineers
06:05 Don’t make the same mistake as Sears
07:38 Human judgment, experience, and empathy
09:02 Why constraints can produce better software
10:25 Product volatility and the Sharpe ratio
11:49 Software engineering is about solving problems
12:38 LLMs as leverage for engineers
13:45 What sets engineers apart
14:25 Your humanity is the key
🔗 Learn more about Arize: https://arize.com
🔗 Explore Arize:Observe: https://arize.com/observe
🔔 Subscribe for more talks on AI engineering, coding agents, evaluation, observability, and the future of software development:
https://www.youtube.com/@arizeai?sub_confirmation=1
#SoftwareEngineering #CodingAgents #AIEngineering When AI Can Write Code, What Are Software Engineers Worth? | Citadel](https://i.ytimg.com/vi/TllPOmVWF8s/mqdefault.jpg)
