Meet the Fleet: Designing Multi-Tenant Autonomous Agents for Deterministic Execution
The tech industry's obsession with general-purpose AI chatbots has created a misconception in network engineering. Prompts sent directly to an off-the-shelf Large Language Model (LLM) might write a decent Python script, but giving a chat interface raw execution privileges on a core enterprise router is a bad idea.
LLMs are inherently probabilistic text generators. They lack transactional awareness, cannot guarantee deterministic outcomes, and are prone to subtle hallucinations. Passing an unstructured prompt like "optimize my BGP routes" directly to an LLM risks executing CLI commands that isolate part of a data center fabric.
Safely bringing artificial intelligence to Network Operations (NetOps) requires moving past conversational chatbots. It calls for an Agent-Native Architecture, a framework where specialized, role-based software agents operate inside isolated execution sandboxes that keep AI reasoning separate from network state execution. This post describes our design. The agents below are planned and are not yet wired into the product.
Decoupling Reasoning from Execution
In a deterministic control plane, an AI model never directly touches a network device's command-line interface or API endpoint. Instead, the architecture splits every operation into two distinct layers:
- The Reasoning Layer: Evaluates intent, parses natural language, and suggests proposed operational plans based on contextual telemetry.
- The Execution Tier: A compiled, strongly typed control plane that validates the proposed plan against hard physical constraints, simulates the blast radius, and executes atomic state changes only after strict verification.
By placing a compiled control plane between the AI reasoning engine and the physical hardware, network engineering teams can use autonomous reasoning while execution stays deterministic.
Meet the Fleet: Four Planned Agent Blueprints
Instead of relying on a single, monolithic AI model forced to handle every operational task, an agent-native architecture uses a fleet of specialized agents. Each has a narrow job description.
Agents and Roles
- Scout (Discovery & Ingestion): Planned. Scans network environments to discover active IP endpoints, topology shifts, and hardware states, feeding raw observation telemetry into the primary database tier.
- Polyglot (Protocol & Model Translation): Planned. Acts as a universal adapter, converting vendor-agnostic operational intent into precise, multi-vendor syntax across Cisco, Juniper, Arista, and cloud-native APIs.
- Truth Seeker (Drift & Root Cause Analysis): Planned. Compares documented configuration intent against live operational reality to identify state drift, unexpected route leaks, and security anomalies. Drift detection is in development.
- Safety Net (Pre-Flight Simulation): Planned as an agent. Before a proposed configuration change is applied to production, it clones the live topology graph in memory and runs a simulated test to check that no routes break and no subnets collide. A what-if pre-flight check ships today as ordinary code, without an agent.
Concurrency at Scale: Go Worker Pools
Running dozens of autonomous agents across hundreds of enterprise tenants is a distributed systems problem. Dedicating a virtual machine or heavy application runtime to every customer agent task is slow and expensive.
Our design handles the concurrency with Go worker pools and native goroutines.
Goroutines are lightweight execution threads managed by the Go runtime, starting with a stack of about two kilobytes each. That makes it practical to run many concurrent agent loops across tenants on one machine pool. We have not published a concurrency limit.
When a customer triggers a discovery job or a drift analysis, the Go Control Plane enqueues the task, assigns an available worker goroutine, and injects the client's isolated execution context.
Multi-Tenant Isolation via RLS and Graph Partitioning
When multiple enterprise clients share a multi-tenant agent execution platform, data isolation must be enforced at the deepest database layers. It cannot rely on application-level filtering alone.
Agent-native control planes enforce strict multi-tenancy across all storage engines:
- PostgreSQL Row-Level Security (RLS): Every database table storing IP allocations, device logs, or agent credit ledgers includes a tenant isolation key. When an agent loop runs, the session sets a secure tenant context. PostgreSQL enforces RLS natively at the database kernel level, so a query cannot read another client's records.
- Graph Database Partitioning: Every node and relationship in the spatial graph includes tenant identifiers. Graph traversal algorithms append strict tenant filters to every hop, ensuring that topological pathfinding never crosses tenant boundaries.
- Isolated Vector Spaces: The design scopes local vector memory (
pgvector) to tenant boundaries so semantic log searches stay private to each tenant. Semantic search is in development.
The Future of Safe Network Automation
Autonomous networks are becoming practical, but building them means putting operational safety first.
By replacing unpredictable AI chatbots with specialized agent fleets operating inside compiled Go execution sandboxes, the goal is for enterprise teams to automate complex NetOps workflows while keeping control deterministic.