Three Frameworks, Three Opinions on What Matters in AI Agents
Open-source AI frameworks for agents are emerging with sharply different priorities, from telemetry-first observability layers to gateway-focused harnesses and filesystem-driven deployment stacks, and those design choices reveal how teams think AI agents should be controlled, monitored, and shipped into production.
Agent Beacon treats the agent as something you watch before you try to govern. It wires AI coding agents such as Claude Code, Codex CLI, Cursor, and Claude Cowork into a normalized record of everything they do across local laptops, CI jobs, and cloud runtimes, exporting OpenTelemetry data into a local collector. OpenClaw and Hermes, by contrast, are opinionated about control: they agree an agent harness must keep a runtime, gateway, and memory in place so agents can operate autonomously and unattended, but they disagree about which of those should be the primary control point. Eve goes in yet another direction, treating the filesystem itself as the control plane for how agents behave and how they reach production.
The result is not one “right” AI agent architecture but three different stacks that implicitly answer the same question: in a world of autonomous system frameworks, do you trust logs, gateways, or files more?
Agent Beacon: Telemetry First, Governance Later
Agent Beacon’s philosophy is simple: before you talk about AI governance, you need reliable, detailed AI agent telemetry. It installs locally, discovers supported runtimes, and configures those agents to stream OpenTelemetry data into a bundled collector on localhost. For tools such as Cursor, it hooks into local endpoints to capture sessions, prompt submissions, tool use, command execution, approval decisions, and file edits, then normalizes everything into JSON logs that a local dashboard can read or teams can forward into their own SIEMs.
Beacon’s stance on control is notably modest. It runs without an account, defaults to full telemetry, and adds configurable retention modes so teams can drop prompt text, raw attributes, command output, or diffs, or keep redacted content under size limits. This is observability designed not to centralize power but to make AI coding agents legible wherever they run. The trade-off is scope: the current public build supports agent runtimes across local endpoint, CI, and cloud-agent telemetry paths, but omits kernel and process monitoring, shell history, broad browser and SaaS telemetry, and general-purpose credential-use attribution. Beacon is an opinionated bet that visibility, even if incomplete, is the first production feature any agent stack needs.
One quotable lesson from Beacon’s design is that “telemetry is the first control surface for AI agents, even when it stops short of full system monitoring.”
OpenClaw vs. Hermes: Gateway Control or Memory Control?
OpenClaw and Hermes share a core definition of an agent harness: software that turns a model into a system capable of operating autonomously by keeping a runtime alive between tasks, carrying messages through a gateway, and persisting memory across sessions so the agent can run unattended. Where they diverge is which of those components should own the control plane.
OpenClaw is unapologetically gateway-first. It started as an independent project centered on a central gateway that lets one agent answer on WhatsApp, Discord, Slack, and other channels while drawing on a public skills marketplace. That breadth attracted platform vendors: Nvidia wrapped OpenClaw in NemoClaw, an OpenShell runtime that sandboxes agents and enforces policy from outside the agent’s reach, while Microsoft baked it into Windows execution containers and shipped Scout, a always-on enterprise agent with its own identity and links into Teams, Outlook, and SharePoint. In both cases, governance and identity are layered around a community gateway that was initially light on those concerns.
Hermes takes the opposite path with a memory-first design. Released under an MIT license, written in Python, and meant to run persistently on infrastructure a team owns, it starts from the premise that the agent’s memory of a developer’s work is the real control surface. One agent can carry context across weeks and refine its own skills, while gateways and channels remain secondary. That inversion matters: memory, more than channel reach, is becoming the durable form of lock-in, and platform vendors know it, which is why Nvidia’s NemoClaw blueprints already run Hermes agents inside the same governed runtimes they use for OpenClaw. Security audits underscore why that governance layer is necessary, with malicious skills and exposed instances discovered in the wild, the very gaps these governed runtimes are meant to close.
Eve: Filesystem-First Architecture for Enterprise Deployment
Eve represents a third philosophy: treat the filesystem as the main organizing structure for AI agent architectures. It provides a filesystem-based project layout with directories for instructions, tools, skills, subagents, communication channels, and scheduled tasks so teams can define behavior without rebuilding infrastructure. Each capability is a file; a single configuration file wires them together, instructions live as Markdown, tools are TypeScript modules, and reusable knowledge is organized as skills, all auto-discovered at build time with no registration boilerplate.
Where OpenClaw and Hermes argue over control, Eve focuses on being one of the most practical agent deployment tools for production. It adds durable execution where each conversation is a workflow that can pause, survive failures or deployments, and resume from the last step, plus sandboxed code execution that can run locally via Docker-like adapters or in production through a sandbox service. Observability is wired through OpenTelemetry so every model call, tool invocation, and sandbox command becomes a trace exportable to existing monitoring platforms or viewed through an observability interface. The framework ships with integrations to services like Slack, GitHub, Snowflake, Salesforce, Notion, and Linear using Model Context Protocol or OpenAPI-described APIs, and the same agent can be deployed across Slack, Discord, Microsoft Teams, Telegram, GitHub, and HTTP APIs without code changes.
Eve arrives with a command-line tool that scaffolds agent projects and deploys them through standard workflows, and commentators are already watching how portable it will be outside its native ecosystem as adoption grows. It is squarely aimed at enterprises that want autonomous system frameworks without giving up deployment discipline.
Where These Philosophies Converge—and What Comes Next
Viewed together, Beacon, OpenClaw/Hermes, and Eve map a spectrum of AI agent architectures: observability-first monitoring, control-centric harnesses, and filesystem-first deployment frameworks. Beacon’s mission is visibility for local and cloud agents, not yet full system forensics. OpenClaw and Hermes fight over whether gateways or memories are the main control levers, while governed runtimes from platform vendors wrap them both. Eve focuses on shipping agents as structured projects with durable workflows and rich observability.
The deeper trend is that platform vendors no longer want to choose between breadth and depth. Nvidia and Microsoft are competing to own the runtime layer around whichever agent stack customers bring, adding governance, identity, and observability on top. Their runtimes already treat OpenClaw and Hermes as interchangeable plug-ins, and they see memory and telemetry as long-term sources of stickiness. At the same time, developers are gravitating toward open-source AI frameworks that preserve local control over logs, runtimes, and deployments.
The clear takeaway is this: future agent deployment tools will not be single monoliths. They will braid together Beacon-like telemetry layers, OpenClaw- or Hermes-style control planes, and Eve-like project structures. Teams that pick only one philosophy—logs without governance, gateways without memory, or files without runtimes—will find themselves constrained as agents stop being apps we open and become persistent systems that share our workflows. The smart move is to design for all three from the start.
