AgentOS: Self-Healing Control Plane for AI Fleets

Agents shouldn't just execute tasks but should operate.Agent OS is the zero-trust control plane that runs AI fleets like production infrastructure and autonomously recovers when agents die mid-mission

Comment

⬢ Agent OS: The Autonomous Operations Control Plane for AI Fleets

💡 Inspiration

Most AI agent demos today follow a brittle pattern:
$$\text{Prompt} \longrightarrow \text{LLM} \longrightarrow \text{Tool Call} \longrightarrow \text{Output}$$

While this works in isolated demos, it collapses in enterprise production. The real operational question facing AI engineering is:

When dozens of autonomous agents execute long-running workflows across distributed systems at 3 AM, who manages identity, enforces security boundaries, persists state across crashes, and recovers the mission when an agent dies mid-execution?

Kubernetes solved lifecycle management, auto-healing, and declarative scheduling for microservice containers. We built Agent OS to provide that exact operational control plane for autonomous AI fleets.

🚀 What It Does

Agent OS turns autonomous agent fleets into resilient, self-healing infrastructure:

  1. Autonomous Mission Planning (Gemini 3.5 Flash): Decomposes natural language goals (e.g., "Launch Product X campaign by Friday within ₹1,00,000") into a validated, Directed Acyclic Graph (DAG) of interdependent tasks.
  2. Capability-Based Registry & Discovery: Agents publish declarative manifests with identity URIs, permissions, and live reliability scores. Tasks are matched dynamically via capability ranking: $$\text{Score}(A) = w_r \cdot R(A) - w_l \cdot L(A) - w_c \cdot C(A) - D(A)$$ (where $R$ is reliability, $L$ is latency, $C$ is cost, and $D$ is degradation penalty).
  3. Subtask Checkpointing & Persistent State: State is externalized to Google Cloud Firestore after every subtask completion. An agent crash loses only seconds of compute, never the entire mission.
  4. Zero-Trust Security Gateway: Every tool invocation is intercepted and validated against manifest permissions before execution ($\text{Identity} \rightarrow \text{Permission} \rightarrow \text{Policy}$) with an immutable audit log. Unauthorized actions (e.g., Finance Agent probing payment execution) are blocked live.
  5. Self-Healing Recovery Engine: When an agent fails, the recovery engine triggers an autonomous escalation ladder: $$\text{Failure Detect} \longrightarrow \text{Restore Checkpoint} \longrightarrow \text{Gemini Diagnosis} \longrightarrow \text{Re-Discover Backup} \longrightarrow \text{Resume Task}$$ The mission finishes without human intervention, maintaining $0$ lost state.
  6. Mission Control Observability: A modern, interactive multi-page React/Vite dashboard providing live SVG DAG graph visualization, real-time Server-Sent Events (SSE) telemetry, gateway audit trails, and dark/light modes.

🛠️ How We Built It

  • Gemini 3.5 Flash & Vertex AI (Google GenAI SDK): Used for schema-constrained task graph decomposition, per-step agent reasoning, and autonomous failure diagnostics.
  • Google Agent Development Kit (ADK): Fleet agents are built as Google ADK agents with gateway-wrapped tool handlers, enforcing zero-trust constraints natively inside the execution framework.
  • Google Cloud Run: Fully containerized serverless hosting for the unified FastAPI backend and React frontend with scale-to-zero efficiency.
  • Google Cloud Firestore: Provides durable, acid-compliant storage for the agent registry, mission checkpoints, memory banks, and immutable audit logs.
  • Google Cloud Pub/Sub: Serves as the asynchronous event backbone streaming 16 lifecycle events (MISSION_PLANNED, AGENT_FAILED, AGENT_REPLACED, TASK_COMPLETED).
  • Frontend Architecture: Built with React, TypeScript, Vite, React Router, and Lucide icons with a glassmorphic design system and system-aware dark/light theming.

⚡ Challenges We Ran Into

  1. Making Recovery an Emergent Property, Not a Scripted Fallback:
    We avoided hardcoded try/catch fallbacks. Recovery had to emerge naturally from the capability registry. We designed overlapping agent capabilities (e.g., Content Agent v1.4 and Creative Agent v2.1 both possess campaign_copy), allowing the recovery engine to re-query the registry using the same ranking algorithm used for initial scheduling.
  2. Deterministic Chaos Injection for Judging:
    To prove self-healing capabilities on demand, we built failure simulation directly into the API (POST /api/missions/{id}/kill-agent). This terminates a running agent mid-task, exercising the exact exception path of a real-world infrastructure timeout.
  3. Model Resilience & Fallback Parity:
    To ensure the control plane never fails due to API rate limits or quota drops during evaluation, every Gemini prompt includes schema fallbacks with identical JSON contracts.

🏆 Accomplishments We're Proud Of

  • The Autonomous Recovery Moment: Killing an agent while executing subtask $5/7$ and watching the system restore state to $71\%$, diagnose the failure, reassign the task to a healthy backup agent, and reach MISSION_COMPLETED with 0 human interventions.
  • Inside-Out Zero-Trust Enforcement: Building tool execution wrappers within Google ADK that guarantee prompts cannot escalate permissions beyond an agent's registered manifest.
  • 31/31 Automated Test Coverage: A complete test suite exercising end-to-end mission lifecycles, chaos recovery, and permission boundaries in CI/CD.

🧠 What We Learned

Autonomy is fundamentally a distributed systems and control plane problem, not just a prompt engineering challenge. Once state is externalized to persistent storage, permissions are bound to manifests, and state changes flow through an event bus, self-healing architectures and zero-trust security become natural properties of the fleet.

🔮 What's Next for Agent OS

  • Multi-Cloud & Edge Agent Federation: Discovering and delegating tasks to remote agent nodes across disparate VPCs.
  • Automated Canary Rollouts & Rollbacks: Automatically rolling back agent versions when real-time reliability $R(A)$ drops below threshold $\tau$.
  • OpenTelemetry & Prometheus Native Export: Exporting agent execution traces directly into enterprise observability stacks like Datadog, Grafana, and Cloud Monitoring.

Built With

Share this project:

Updates

Submission history