AI agents are powerful, but without visibility they become a risk
AI agent monitoring refers to the continuous tracking, inspection, and analysis of autonomous AI agents as they run in real user environments, so teams can see behavior, detect failures, and adjust policies before issues scale across production systems. As enterprises rush into agent-based workflows, those agents are often embedded inside tools, running with human-level permissions, and acting across systems that were built for people rather than software. The result is an invisible layer of automation that is hard to debug and even harder to govern. Research cited by Axios found companies typically run 67 generative AI tools, with 90% lacking proper licensing or approval, which means most organizations cannot say which agents are active, how they behave, or where sensitive data flows. New open-source AI infrastructure tools aim to close this visibility and control gap.
Latitude turns messy agent conversations into an observability platform
Latitude’s open-source platform is an agent observability platform built for live, production use rather than lab demos. At the base is a discovery layer that gathers thousands of conversations from real users and clusters them into a single view of what people ask, where they hesitate, escalate, or drop off. Teams can slice usage by persona, from power users to one-time visitors to accounts that hit failures most often, while inspecting individual sessions with their cost, latency, and problems. A semantic search lets engineers type questions in plain language—such as where users request a feature the agent lacks—and see matching conversations immediately. A second layer turns repeated breakages into named signals, counting frequency and attaching likely causes, which can be promoted into monitors that run against every new interaction. A third layer pushes projects, traces, and datasets into existing coding tools via MCP, closing the loop inside the developer workflow.
From scattered failures to closed-loop debugging in production
Latitude focuses on the invisible moments where AI agents fail in production and makes them actionable for engineering teams. When an agent keeps failing in the same way, the platform collapses those recurring fragments into a single, labeled signal tied to the probable reason, rather than leaving issues buried in thousands of logs. Saved searches can be upgraded into ongoing monitors so new conversations are scanned automatically and emerging patterns are caught before they impact more people. Production transcripts can be converted into datasets and reused as test sets, turning real incidents into regression tests that confirm a fix holds before deployment. Through an MCP server, Latitude streams signals, searches, and datasets directly into coding agents and tools such as Claude Code, which also allows tracking token spend per task. Distributed under an MIT license, the system can run on a team’s own infrastructure and be modified to match local needs.
Tailscale’s Aperture puts identity and sandboxing around agents
While Latitude focuses on AI agent monitoring and debugging, Tailscale’s Aperture targets control and safe execution. Aperture acts as a centralized AI gateway that monitors and routes large language model requests using Tailscale’s identity layer, authenticating both humans and machines without spreading API keys across tools. The gateway stores keys centrally and routes calls to providers such as OpenAI, Anthropic, and Google, without changing existing workflows. Avery Pennarun, Tailscale’s CEO, argues that “agents need boring infrastructure around them – identity management, limited access controls, carefully tracked logs, and sandboxes” so they can work without turning every developer laptop into a risk point. Aperture now adds a browser-based chat interface, universal data connectors for MCP and APIs, and sandbox support so agents can interact with internal data sources and tools while running inside controlled environments. Humans define policies and boundaries, and the infrastructure enforces them as agents operate.
Why open-source AI infrastructure tools now matter as much as the agents
Both Latitude and Tailscale’s Aperture show that AI infrastructure tools are becoming as important as the agents they support. Agent frameworks and models can change quickly, but enterprises need consistent layers for observability, identity, policy, and debugging if they want reliable enterprise AI deployment that is safe to scale. By addressing the invisible nature of agents—what they do in production, how they fail, and which permissions they hold—these platforms turn opaque automation into systems that can be inspected and tuned. Open-source licensing is a key part of that shift: Latitude’s MIT license and self-hosting option lower the barrier to adoption and let teams customize pipelines, monitors, and integrations for their own stacks, while Aperture keeps the AI stack modular so organizations can swap models and tools without starting over. In practice, that means enterprises can adopt agents with confidence instead of blind trust.
