Observer Agents

Sensors for the Agent Ecosystem

Observer Agents – Sensors for the Agent Ecosystem

Observer agents are the eyes and ears of the agent ecosystem, continuously sensing and interpreting raw signals, and providing the awareness that allows the Agentic Mesh ecosystem to adapt, respond, and act in real time.

In a factory, sensors listen to the machinery, actuators act on the assembly line, and controllers bind them together into a working system. The same is true in the Agentic Mesh: observer agents are the sensors that continuously scan for change in contrast to traditional task-oriented agents that execute tasks. A thriving agent ecosystem needs both. Without sensors, the system lacks awareness; without actuators, it cannot move; and without coordination, it cannot function as a whole.

Observer agents stand apart from today’s most common agents. While prompt-driven agents react to human requests and actuator-style agents execute tasks, observers are focused on awareness. They are always listening-monitoring data streams, telemetry, and events-and they filter, aggregate, and classify signals to separate noise from insight. In this sense, they are not just passive watchers; they are the Mesh’s first line of intelligence, creating the context that other agents need to act responsibly and effectively.

Beneath the surface, observer agents are designed as layered architectures. At the lowest level, they capture raw events, such as price fluctuations or system anomalies. These raw signals can be passed along or aggregated by higher-level observers, which filter further, correlate events, and even generate new, more meaningful signals. The result is a cascading hierarchy where each level transforms low-level noise into increasingly higher-level insight, enabling the Mesh to progress from detection to understanding. Observer architectures, in this way, act as pipelines that refine raw inputs into actionable intelligence.

Finally, observer agents do not operate in isolation-they are the connective tissue of the agent ecosystem. The insights they generate provide the inputs that goal-oriented agents use for decision-making and can serve as the triggers that activate task-oriented agents. An observer might detect a compliance anomaly, issue an event that represents the insight, and initiate a task agent to file a report or escalate the issue. In the broader Agentic Mesh, observers act as the nervous system, delivering the awareness and intelligence that allow agents and fleets to operate as safe, reliable, and enterprise-grade ecosystems.

This article will explore:

• What observer agents are and how they differ from today’s prompt-driven and actuator agents.

• Observer agent architecture, including layered hierarchies that filter, aggregate, and generate insights.

• Integration into the Agentic Mesh, where observer agents provide the awareness and triggers that bind the ecosystem together.

Observer Agents – What are they and How are they Different?

In a factory, the simplest building blocks of automation are sensors and actuators. Sensors watch: they detect temperature, vibration, or pressure. Actuators act: they move parts on the assembly line, switch valves, or control motors. Controllers sit in between, binding them into a working system. The same logic applies in the world of agents. Task-oriented agents are like actuators—they act on instructions and execute tasks. Observer agents, by contrast, are like sensors—always listening, always scanning for changes, and feeding that awareness back into the broader system.

In agentic mesh, three types of agents work together to transform raw events into meaningful actions: observer agents, goal-oriented agents, and task-oriented agents. Figure 1 shows how these categories—sensors, orchestrators, and actuators—form a pipeline that allows large, distributed systems to observe their environments, make sense of what is happening, and act with precision. Observer agents, at the foundation, serve as the ecosystem’s “eyes and ears.” They capture events such as alerts, faults, or news, aggregate them, and then analyze their meaning. Their role is to ensure that higher-level signals are forwarded into the system, allowing other agents to work with distilled insights rather than unfiltered noise.

Figure 1, Observing, Goal-Seeking, and Executing

The second agent group, goal-oriented agents, act as orchestrators that interpret information in the broader context of the ecosystem. They use shared workspaces—sometimes called “super-contexts”—to bring together observations, decide what matters, and plan responses. These agents do not execute tasks directly but instead organize workflows, delegate responsibilities, and set priorities. They bridge the gap between raw data and actionable work, ensuring that the system’s responses remain coherent, timely, and aligned with higher-level objectives.

Finally, task-oriented agents take on the role of actuators, carrying out specific tasks based on the plans set by goal-oriented agents. They decompose complex problems into executable steps, identify the appropriate tools or collaborators needed, and drive concrete outcomes. Whether it is calling APIs, interacting with systems, or performing detailed actions, task-oriented agents form the “hands” of the ecosystem. Together, these three agent types form a loop of observing, orchestrating, and executing—an essential structure for building scalable, enterprise-grade agentic systems.

Unfortunately, today’s agent ecosystems are missing this critical sensing capability. Most agents are built to respond to human prompts, queries, or commands. They wait passively until someone asks for something, or until they are scheduled to perform a task. What is absent is an agent that can “listen” continuously to its environment—whether that environment is market data, log streams, IoT sensors, or social signals—and broadcast relevant events in real time. Observer agents fill this gap. They are not driven by requests from people, but by the flow of signals in the world around them.

This makes observer agents fundamentally different from the task-oriented models we see today. Task agents wake up, do work, and return a result; they live in cycles of action. Observer agents live in cycles of awareness. They don’t wait to be told what to do; they notice, analyze, and broadcast what’s happening. In doing so, they give the ecosystem eyes and ears—something most current agent frameworks lack. Without observers, agents are clever but blind, acting without the context of a dynamic, real-time environment.

Observer Agents – How do they Work?

The Observer Agent Architecture, in Figure 2, shows how raw events are captured, processed, and transformed into actionable insights within an agentic ecosystem. At its core, the architecture separates the responsibilities of event detection and event handling: the observer tool continuously monitors for signals—using periodic checks or event listeners—while the observer agent subscribes to these published events and applies algorithms to filter, aggregate, and analyze them. This design ensures that complex systems can sense their environment in real time, reduce noise, and forward meaningful information to other agents for coordinated action.

Figure 2, Observer Agent Architecture

Observer agents play the foundational role of detecting signals and translating them into actionable insights. The diagram above breaks down this process into two key components: the observer tool and the observer agent. The observer tool runs an event loop that makes periodic calls (via callback) to a tick() function. The tick() function itself has two personalities: it can operate in a one-shot mode, checking whether an interesting event has occurred and then emitting it, or it can take on a listening role, waiting—sometimes indefinitely—for an event to arrive, and then calling emit() to transform that signal into a structured event ready for analysis.

Once an event is generated by the observer tool, it is handed off to the observer agent through a publish-subscribe model. The agent subscribes to the event queue and processes incoming information through its internal algorithm. This step is critical, as it is where raw signals are turned into something more meaningful: aggregated patterns, filtered signals, or analyzed insights.

In this way, observer agents act as broadcasters within the larger agentic mesh. After applying their algorithm, they can publish higher-level insights to other agents, who may then use these outputs to orchestrate workflows or execute specific tasks. This makes the observer agent architecture a keystone for real-time responsiveness in complex systems: it allows organizations to move from passive data collection to active, intelligent monitoring that fuels decision-making across the entire ecosystem.

At the technical level, observer agents rely on observer tools—data feeds, sensors, APIs, or event listeners—that capture raw signals from the environment. But raw events are noisy, and not every anomaly matters. The role of the observer agent is to aggregate, filter, and interpret these streams. It may combine multiple weak signals into one meaningful event, or it may discard irrelevant noise while highlighting critical patterns. This filtering role makes them more than just passive consumers of data; they are intelligent intermediaries, producing actionable signals for other agents and people.

This is where they diverge sharply from traditional event-driven architectures. Event-driven systems have long existed in enterprise IT, allowing services to react to triggers such as “new order placed” or “error logged.” Observer agents build on that foundation but add an LLM or reasoning engine as a brain. Instead of simply routing or transforming events, they can correlate across streams, detect subtle patterns, and even generate new insights. An observer agent doesn’t just say “error occurred”—it can say “this error matches a failure pattern seen last month and may indicate an emerging systemic risk.”

Because of this intelligence, observers can be built into hierarchies that mirror real-world sensing systems. At the bottom are low-level observers, capturing raw data like ticks in financial markets, packet flows in a network, or readings from IoT sensors. These agents forward their processed outputs to mid-tier observers, which aggregate across multiple feeds. At the top, high-level observers synthesize signals from many sources, producing strategic insights or triggering orchestrated responses. This cascading design provides a consistent way to manage complexity: each layer filters, aggregates, and interprets, so the ecosystem never drowns in raw data.

Hierarchies of observer agents also make the Mesh resilient. If one observer fails, others continue to operate, and higher-level observers can cross-validate inputs. This layered approach ensures that no single agent becomes a bottleneck or point of failure. It also mirrors how people and organizations process information: individual employees notice details, managers synthesize across teams, and executives focus on high-level trends. By building observer hierarchies, the Agentic Mesh scales human-like awareness into a machine ecosystem.

The value of this architecture becomes clear when comparing it to task-oriented agents. Task agents execute: they file reports, schedule meetings, or run workflows. But without context, they risk acting blindly or inefficiently. Observer agents supply that context. By identifying critical changes in the environment and passing them forward, observers give task agents the insight they need to act intelligently. They are the spark that initiates action and the lens that sharpens decisions.

In practice, observers can serve as both initiators and enablers. A compliance observer might detect unusual trading behavior, generate an event, and trigger a task agent to launch an investigation. A supply-chain observer might aggregate multiple small signals—supplier delays, shipping bottlenecks, demand spikes—and produce a higher-level event that prompts reallocation of inventory. In each case, observers transform raw inputs into meaningful outputs that make the entire ecosystem smarter and more responsive.

Ultimately, observer agents expand the definition of what an agent ecosystem can be. Prompt-driven agents respond to people. Task-oriented agents execute work. Observer agents watch, interpret, and signal change. Together, they create a full loop of awareness and action. Just as factories rely on sensors and actuators working together, the Agentic Mesh relies on observers and task agents to bind awareness and action into one system. This article begins with that distinction—what observer agents are and why they matter—before diving deeper into their architectures and their role in the broader Agentic Mesh.

At their core, observer agents are microservices with a brain. Like any modern microservice, they are lightweight, containerized, and deployable in scalable environments. What makes them unique is the addition of an LLM or reasoning module that allows them to process incoming signals intelligently. This brain distinguishes observer agents from traditional services that merely route or log events—observers can aggregate, filter, interpret, and generate insights in real time, creating higher-order meaning from raw data.

Every observer agent operates around an internal event loop. This loop governs the tools the observer controls, orchestrating how they access the environment. Tools may monitor databases, watch APIs, listen to message streams, or even read sensor feeds. The observer decides when and how these tools should be invoked, ensuring that the agent is continuously attentive without overwhelming the system. This event loop architecture makes observers reliable, responsive, and efficient in managing environmental inputs.

Observer tools can operate in different modes depending on the need. Some are periodic: they execute at regular intervals, scanning for anomalies or new signals in the environment. Others are long-lived listeners: they sit idle but awake, waiting indefinitely for something to occur—a stock price crossing a threshold, a sensor reporting a critical temperature, or a log entry signaling an error. The observer’s event loop integrates these modes seamlessly, allowing multiple tools to operate concurrently without conflict.

The power of the event loop lies in its safety and predictability. Left unmanaged, long-lived listeners can create resource leaks, or periodic tools can overwhelm systems with excessive polling. The observer event loop abstracts this complexity away from developers, offering a managed execution environment that schedules checks, handles failures, and gracefully recovers from errors. In practice, this means observers can safely scale to thousands of tools and streams without collapsing under their own weight.

Once an observer agent detects an event, its job is not complete until it shares it. Observers use a standard “emit” function that publishes events into the ecosystem’s event management layer, often implemented with systems like NATS, Kafka, or Pulsar. Emitted events become first-class citizens in the Mesh: they are timestamped, traceable, and made available for any interested subscriber. This broadcast model ensures that observer outputs are not hidden in silos but are accessible across fleets and ecosystems.

The subscription model makes observer agents especially powerful. Any number of downstream consumers—task agents, goal-oriented agents, or even people monitoring dashboards—can subscribe to the observer’s events. This decoupling allows observers to remain simple and focused on their sensing role, while the broader Mesh decides what to do with their signals. In this way, observer agents form the “nervous system” of the Mesh, continuously generating signals that other agents interpret and act upon.

Because observers are built on a microservices foundation, they inherit all the enterprise-grade practices already well established in the cloud-native world. They can be secured with mutual TLS (mTLS) for encrypted communications, authenticated with OIDC to acquire identities, and authorized with OAuth2 roles for fine-grained access control. These integrations mean that observer agents are not novel from an infrastructure standpoint—they fit into well-understood operational frameworks, reducing barriers to enterprise adoption.

Observers also come with built-in observability. Like any microservice, they can emit logs, traces, and metrics into monitoring platforms. But because they are event-centric, they can also send alerts directly to operations consoles when anomalies are detected. For example, an observer that notices repeated authentication failures might emit both an event to the Mesh and an alert to the security operations team. This dual pathway makes them both part of the agentic workflow and part of enterprise IT operations.

When deployed inside the Agentic Mesh, observers gain an additional layer of trust. Mesh components enforce explainability and traceability, ensuring that every emitted event is accompanied by metadata about its source, reasoning, and context. Zero-trust principles apply at every step: no observer is trusted implicitly, and every interaction must be authenticated, authorized, and logged. This combination of zero-trust posture and traceability ensures that observers can be trusted in sensitive environments, from financial services to healthcare.

Ultimately, the observer agent architecture is about combining familiar enterprise practices with new intelligence. They are microservices, so they inherit scalability, security, and reliability. They have a brain, so they can transform noise into insight. They operate in event loops, so they can manage multiple tools seamlessly. And they broadcast through the Mesh, so they connect sensing to acting. In short, observer agents bring awareness into the Agentic Mesh, ensuring that enterprises are not just building systems that act, but systems that listen, interpret, and evolve in real time.

Let’s walk through a simple example of how observer agents work, using a stock market scenario. Imagine you have an observer agent that “listens” to a live stock ticker feed. Its job is simple: watch the stream of prices, and if anything significant happens—say a stock price jumps more than 5% in a minute—it takes note. This is like a sensor on a factory floor detecting a sudden vibration in a machine: the observer isn’t doing the work of fixing or trading, it’s just watching for changes.

Inside, the observer has a small loop that constantly checks its inputs. In our example, it might connect to both the ticker feed and a financial news feed. Some of these tools check periodically (for example, scanning the news every 30 seconds), while others wait for events to arrive (like live price updates). The observer agent’s loop keeps all this organized—making sure tools don’t collide, that nothing gets missed, and that if a tool crashes, it gets restarted.

When something happens—say the price of Stock A suddenly spikes—the observer agent recognizes this as a meaningful event. It then “emits” the event into the ecosystem. Think of this like the observer writing a short note: “Stock A up 5% in 60 seconds” and dropping it into a central message system such as Kafka or NATS. That message is timestamped and made available to anyone who cares about market signals. The observer doesn’t decide what happens next; it just provides the event.

Subscribers then pick it up. Maybe a trading bot subscribes and decides to buy. Maybe a risk-management agent subscribes and checks if the spike looks suspicious. Maybe a compliance agent logs the event for audit. The beauty is that the observer doesn’t need to know who is listening. It just listens, detects, and signals. In a way, it’s like the factory analogy again: sensors detect vibration, controllers interpret, and actuators act. Observer agents provide the eyes and ears that let the rest of the agent ecosystem respond intelligently.

Observer Agents – Integration with Agentic Mesh

Observer agents, goal-oriented agents, and task-oriented agents integrate to form a scalable, coordinated system, as shown in Figure 3. Each type of agent plays a distinct but complementary role, ensuring that raw signals can be turned into meaningful insights and ultimately into concrete actions. This flow—sensing, orchestrating, and executing—allows organizations to manage complexity while maintaining agility in their operations.

Figure 3, Observer Agent Integration

The process begins with observer agents, which function as sensors. These agents monitor a wide range of events at scale, such as shifts in consumer sentiment or changes in pricing. Rather than acting directly on these events, observer agents publish the information to the broader system. This ensures that the raw observations are captured and made available for higher-level processing, preventing valuable signals from being lost or siloed.

Next, goal-oriented agents step in as orchestrators. They receive event data from observer agents and interpret it within a broader context. For example, a marketing-related event might trigger a goal-oriented agent to create a strategic plan. These agents break down broad objectives into structured goals, coordinate tasks across the system, and determine which task-oriented agents or tools are best suited to carry out the work. Their role is to translate signals into actionable workflows that align with organizational objectives.

Task-oriented agents then take over to execute the detailed steps required to achieve the defined goals. These agents act as actuators, breaking down plans into fine-grained tasks and calling upon the necessary tools or APIs. For example, a goal-oriented agent may ask a task-oriented agent to calculate a market size or produce a specific deliverable, which is then executed step by step until completion. This structure ensures that even complex projects can be managed reliably by decomposing them into smaller, manageable components.

The integration of these three layers—observers sensing, goal-oriented agents orchestrating, and task-oriented agents executing—creates a scalable model for intelligent systems. It allows for real-time responsiveness to external signals, ensures that work is intelligently distributed across agents, and provides a clear path from raw data to completed outcomes. In this way, the system mirrors how human organizations operate at scale, with specialized roles working together in a coordinated loop of observation, decision-making, and execution.

Observer Agents – First Class Members of the Agent Ecosystem

One of the most powerful integration patterns is building hierarchies of observers. At the lowest level, simple observer agents capture raw events—stock ticks, server logs, IoT sensor readings—and forward them onward. Higher-level observers aggregate these streams, filtering noise and combining weak signals into meaningful insights. This tiered abstraction ensures that the Mesh can handle massive amounts of raw data without overwhelming downstream agents, surfacing only the most important events. The result is a pipeline of awareness that scales from fine-grained details to strategic insights.

Observers also play a critical role in activating task-oriented agents. Task agents are the actuators of the Mesh: they carry out specific work when conditions are met. An observer might detect a system anomaly and trigger a remediation agent to restart a service. Or it might spot unusual market activity and activate a trading agent to execute a position. In this way, observers act as initiators of action, turning passive task agents into responsive, real-time participants in the ecosystem.

At the same time, observer agents feed insights into goal-oriented agents. These are higher-order agents tasked with achieving long-term objectives—optimizing a portfolio, maintaining compliance, or orchestrating a supply chain. By providing them with real-time signals, observers enhance their decision-making capabilities. A goal-oriented agent is only as good as the information it receives, and observers ensure that its inputs are both current and meaningful. They become the bridge between low-level signals and high-level strategy.

Observer agents can be arranged into collaborative ecosystems to manage vast streams of events in a scalable way. Observer agents capture signals from multiple sources—ranging from raw data feeds to real-world alerts—and pass them along to other observers. By organizing observers into layered structures, the system can progressively aggregate, filter, and analyze information before it reaches higher levels of the ecosystem. This tiered approach ensures that the flood of incoming signals is refined into meaningful, manageable insights.

Figure 4, Observer Agent Ecosystems

Discovery and reuse of observers is also built into the Agentic Mesh. Like all agents, observers can be published into a registry or marketplace, where other teams or systems can find them. This makes it easy for organizations to share observer agents across domains. A financial market observer might be reused by multiple desks; a compliance log observer might serve multiple departments. Registries give observers the same discoverability and lifecycle management as other agents in the Mesh.

Managing fleets of observers is another integration point. In practice, enterprises will run not just one or two observers, but thousands. Like any other agent type, observer fleets can be deployed and orchestrated with Kubernetes-style fleet management capabilities. This allows organizations to scale observers up or down, roll out new versions, and ensure consistent monitoring across environments. Observers are microservices with brains, and the Mesh treats them with the same operational rigor as any production-grade service.

Observers are also integrated with the Mesh’s control plane. Through control plane services, they can be started, stopped, configured, or throttled dynamically. Administrators can adjust thresholds, switch data sources, or reassign observers to new roles without manual intervention. This centralized control makes observers not only powerful but governable, aligning them with enterprise requirements for security, compliance, and operations.

Together, these integrations transform observer agents from isolated tools into ecosystem enablers. They provide the eyes and ears of the Mesh, trigger actuators into action, inform strategic goal-oriented agents, and operate under enterprise-grade controls. By plugging seamlessly into registries, fleet management systems, and control planes, observers embody the Agentic Mesh philosophy: agents that are not only intelligent but integrated, secure, and scalable. In this way, observers anchor the Mesh’s awareness, ensuring that the ecosystem is not only capable of action, but of perception and insight.

Observer Agent – Ecosystem Topologies

On the internet, sensor topologies appear in systems like CDNs, where distributed nodes detect traffic anomalies and forward them to regional aggregators in a hierarchical structure, and in IoT smart homes, where devices connect to a central hub in a star topology that filters and relays data. Similarly, distributed monitoring systems such as Prometheus or Datadog use federated topologies, with local collectors passing metrics to higher-level aggregators that provide a global, correlated view of system health.

Similarly, in factories, assembly line monitoring often uses a linear topology where sensors track each stage of production in sequence, while SCADA systems employ hierarchical tree structures with field sensors feeding data to PLCs and supervisory systems. For predictive maintenance, sensors on equipment are arranged in mesh topologies, enabling resilient, redundant communication that ensures continuous monitoring even if individual sensors fail.

Figure 5, Observer Agent Topologies

There are three common ways that observer agents can be organized into topologies: star, hierarchical (SCADA-like), and mesh. Each topology provides a different balance of scalability, resilience, and efficiency, reflecting trade-offs between centralized control, structured layering, and distributed collaboration. By mapping these structures onto observer agents, we can see how complex systems can sense, filter, and respond to events at scale.

The Star Topology arranges observer agents around a central node, which acts as a hub for event collection and aggregation. Each peripheral observer listens to its local environment—capturing events such as market signals, security alerts, or operational anomalies—and sends them directly to the hub. The hub filters noise, correlates signals, and forwards only meaningful insights. This design is simple, easy to manage, and ensures that decisions are consistent because they pass through a single point. However, it creates dependency on the hub, which may limit resilience at very large scales.

The SCADA/Hierarchical Topology introduces multiple layers of observer agents, each with its own scope and level of abstraction. At the lowest level, local observers capture raw signals. These are then passed upward to mid-tier observers, which aggregate and contextualize them, and finally to top-tier observers, which detect patterns across large domains. This resembles industrial control systems, where PLCs roll up data to supervisory systems. The strength of this model is scalability and clarity: raw data is progressively refined, ensuring that higher-level agents focus only on the most relevant insights.

In contrast, the Mesh Topology distributes responsibility evenly across all observer agents. Here, each observer not only listens for events but also shares them with neighboring observers, creating redundancy and resilience. If one agent fails, others can still propagate the event across the network. This topology excels in dynamic environments where robustness is critical, such as predictive monitoring or cybersecurity. The tradeoff is greater complexity, since coordination and deduplication are required to avoid overwhelming the system with redundant signals.

Applying these structures to observer agents in the Agentic Mesh, we see that each topology fits different use cases. A star arrangement might work best for a localized domain, such as monitoring a single business process. A hierarchical arrangement could serve large-scale enterprises, where signals must flow from front-line operations up to corporate decision-makers. A mesh design, on the other hand, could be deployed across distributed infrastructures like cloud services or global supply chains, where resilience and adaptability are paramount.

These topologies also highlight how observer agents integrate with goal-oriented and task-oriented agents. In star and hierarchical models, goal-oriented agents may sit above the observer hub or supervisory layer, orchestrating work based on aggregated insights. In a mesh, however, goal-oriented agents might exist throughout the network, receiving inputs from multiple points and dynamically coordinating responses. Task-oriented agents, in turn, benefit from whichever topology ensures that they receive clean, timely, and relevant signals.

Ultimately, observer agent topologies are not one-size-fits-all but instead form a toolkit. By selecting and combining star, hierarchical, and mesh arrangements, organizations can build sensing networks that match their operational priorities—whether that is simplicity, scalability, or resilience. Just as factories, IoT systems, and the internet use different sensor topologies to meet their needs, observer agents in the Agentic Mesh can be deployed in the structure best suited to the environment they monitor and the goals they serve.

Summary

This article has explored the essential role of observer agents within the Agentic Mesh, positioning them as the sensors of the ecosystem—always on, always listening, and always filtering noise into actionable insights. We examined how observer agents differ from prompt-driven and task-oriented agents, their layered architectures that transform raw signals into meaningful intelligence, and their integration with goal-oriented and task-oriented agents to create a full cycle of awareness, orchestration, and execution. By looking at architectures, integration patterns, and real-world sensor topologies, we saw how observer agents provide the nervous system for enterprise-grade agent ecosystems.

In my own mind, the opportunity is clear: anyone can begin to design and deploy their own observer agents, hierarchies, and topologies to bring real-time awareness into their systems. With the Agentic Mesh as the foundation, you can build ecosystems that listen as intelligently as they act—star topologies for simplicity, hierarchical designs for scale, and mesh arrangements for resilience. By combining these patterns, organizations can create sensing agent ecosystems that not only monitor but also interpret and respond dynamically to the world around them, unlocking the promise of agents that are not just clever but truly aware.

---

Looking for more?
👉 Discover the full O’Reilly Agentic Mesh book by Eric Broda and Davis Broda

🎧 Follow co-hosts John Miller and Eric Broda on The Agentic Mesh Podcast on Youtube, Spotify and Apple Podcasts. A new video every week!