## The Agent Harness: An Agent Is More Than a Loop

Today we're diving into the AG2 agent, its harness, as this plays a crucial role in having a reliable long-term agent.

An agent has moved on from a simple loop around LLM and tool calls. It has memory that spans thousands of turns. It can run tools in parallel, delegate subtasks, and call back to a human. It keeps producing under context pressure. It can be traced, metered, and gated. This post zooms in on that machinery — what the AG2 beta harness gives you, and how to reach for each part.

## Networks You Can Deploy

Moving agents to separate processes usually means rewriting the networking layer. With the AG2 Network, it's a constructor argument.

The Hub absorbs the topology difference. Replace `LocalLink` with `WsLink`, add an auth registry, and your agents are distributed. This post covers the three things you actually wire up to go from a local prototype to a network you can deploy.

## What Survives, Survives Exactly

Three agents are mid-conversation. The hub process restarts. When it comes back up, does the conversation survive?

Yes. Exactly as it was, envelope for envelope, in the same order, with the same adapter state. No partial log or replay from an approximation. The write-ahead log is the exact conversation.

The previous posts showed _what_ the network lets agents do. This one explains _why you can trust it_.

## Choreography You Can Dial In

We've touched on the four built-in conversation shapes; now you need to make them survive contact with the real world.

In the first post — [_One Coherent Agent Isn't Enough_](https://docs.ag2.ai/docs/blog/2026/05/14/AG2-Action-Driven-Network/) — you opened a channel, watched agents take turns, and saw the hub fold envelopes into a durable thread. That's the _shape_. This post is about the _dials_ on top of that shape — the knobs that turn a loose multi-agent free-for-all into something you'd actually run when an agent goes quiet at 2am, a step needs to time out, or a sub-conversation has to stay off the main thread.

## One Coherent Agent Isn't Enough — Action-Driven Networking with AG2

A single agent is a great starting point, but real work extends beyond just one.

Real work spans people, teams, services, and machines. A support escalation touches a triage bot, a knowledge agent, an on-call engineer, and a postmortem writer. None of them is "in charge" — they each take a turn, in the open, over a shared thread that outlives any one of them.

That's what the **AG2 Network** is built for: a layer where stateful, identity-bound, choreographed _actions_ live. By the end of this post you'll have run all four conversation shapes the network ships with — and have a flavor for AG2's new multi-agent network, which we'll expand on in upcoming posts.

## Building low-latency voice agents in 3 lines of code with GPT Realtime 2

OpenAI recently announced [advanced voice intelligence in the API](https://openai.com/index/advancing-voice-intelligence-with-new-models-in-the-api/), including **GPT Realtime 2** for lower-latency, more natural spoken interactions. **AG2 Beta** wraps that class of model behind **`LiveAgent`**: one bidirectional session, continuous audio in and out, and provider-side voice activity detection so users can speak and interrupt like on a phone call—not like a walkie-talkie app.

In this post we walk through why that matters, how **`LiveAgent`** compares to the classic **STT → Agent → TTS** stack, and how to add **tools** and **subagent-style** delegation without giving up the realtime voice surface.

## AG2 Beta: Stronger Foundation for Real-World Agents

The original **AutoGen** and later **AG2** architecture helped define the early agent ecosystem. It enabled real systems, shaped how many developers thought about agent orchestration, and gave us firsthand experience building and operating agent applications in practice.

That experience also made the limits of the original design clearer over time. As the agent ecosystem matured, expectations changed. Agents increasingly needed to fit into real application environments with concurrent users, explicit session boundaries, platform identities, persistence layers, and integration points that could not be treated as incidental details.

We found that some of these needs were challenging to address cleanly inside the original framework model. In many cases, shipping more production-suitable behavior meant adding complexity around the edges instead of improving the core abstraction itself, taking the focus of developers away from building agentic capabilities. That is a big part of why we decided to create **AG2 Beta**: a new framework track built around lessons we learned from the original AG2 to better support modern, real-world agentic systems.

You can read more about the motivation behind **AG2 Beta** in the [AG2 Beta overview](https://docs.ag2.ai/docs/user-guide/motivation/).