Agent Launchpad: Self-Healing Middleware for Agent Runs

Middleware dashboard about the successful request.
Shows denied entry trace in dashboard.

Inspiration

We built Agent Launchpad to make agent-based workflows dependable in real-world systems. Existing agent runtimes were powerful but brittle — long-running runs would fail silently from transient infra, dependency drift, or subtle prompt/runtime mismatches. We wanted a pragmatic middleware that detects, isolates, and heals failures automatically so teams can run agents reliably at scale without constant manual triage.

What it does

Agent Launchpad sits between an orchestrator and agent executions to: Observes: Collects run telemetry (inputs, outputs, environment, errors). Detects: Classifies failures (transient infra, resource exhaustion, bad inputs, model hallucination). Recovers: Applies automated fixes (retry with backoff, environment reset, sanitization, fallback model or prompt variants). Learns: Records effective remedies and adapts heuristics over time. Surfaces: Provides audit trails and actionable alerts for unrecoverable cases.

How we built it

Architecture: Lightweight middleware service that plugs into existing runner APIs, implemented as a small HTTP/gRPC layer for minimal friction. Instrumentation: Structured logging and per-run metadata capture (inputs, spec, deps, container snapshot, timing). Failure classification: Rule-based + lightweight ML classifier trained on historical runs to map symptoms to repair actions. Recovery strategies: Encapsulated handlers (retry, workspace reset, prompt rewrite, resource bump, model fallback) implemented as composable middleware steps. Safety and observability: Idempotent recovery operations, strong invariants on state changes, and end-to-end tracing for replay/debugging. Tech choices: pragmatic stack (TypeScript/Node or Go for the service, containerized runners, persistent store for run history and policies), with small, testable modules so strategies are easy to add.

Challenges we ran into

Noisy signals: distinguishing transient infra glitches from logical failures required careful feature engineering and conservative defaults to avoid harmful automated changes. State management: ensuring recovery actions are idempotent and safe when runs are retried or resumed. Balancing automation vs control: designing safe rollback and escalation policies so automation helps without masking systemic issues. Observability gaps: instrumenting heterogeneous runner environments (containers, VMs, serverless) for consistent diagnostics. Prompt variability: creating robust prompt-rewrite heuristics that don’t introduce new failure modes.

Accomplishments that we're proud of

Reduced manual intervention: automated recoveries cut human triage for common transient failures by a large percentage. Modular handlers: added new recovery strategies without modifying core runtime code. Reproducible debugging: snapshot-and-replay capability made root-cause analysis fast and reliable. Policy-driven safety: operators can tune aggressiveness per workspace, limiting blast radius. Clear audit trails: every automated action is logged, explainable, and reversible where possible.

What we learned

Conservative automation wins: start with narrow, well-tested recoveries and expand via measured A/B rollouts. Observability is the foundation: reliable detection depends on rich, consistent telemetry more than clever ML. Small, composable strategies scale: handlers that operate on clear invariants are easier to validate and maintain. Human-in-the-loop for edge cases: automation plus clear escalation yields the best uptime and trust. Continual learning is necessary: recovery effectiveness improves when the system captures outcomes and tunes policies.

What's next for Agent Launchpad: Self-Healing Middleware for Agent Runs

Adaptive policies: automated tuning that adjusts retry/backoff/handler selection based on past success rates per workload. Wider integrations: native adapters for popular orchestrators and model providers to reduce integration work. Policy marketplace: shareable, audited recovery strategies and heuristics for common agent patterns. Simulated chaos testing: synthetic failure injection to validate handlers and measure effectiveness before production rollout. Explainable automation: richer, human-readable rationales for each automated repair and easier one-click rollbacks. Governance & compliance: add policy controls for safety-sensitive runs (data redaction, manual approval gates).