AutoHeal.ai

Inspiration

In modern B2B software engineering, no company builds in a vacuum. Enterprise applications rely on a complex network of third-party SaaS APIs for payments, CRMs, logistics, and authentication. However, this architectural dependency creates a massive vulnerability: Integration Debt.

When a third-party vendor updates their API schema unannounced—changing a required field name or nesting data identifiers—downstream pipelines shatter instantly. These schema validation failures (400 Bad Request or 422 Unprocessable Entity) trigger emergency alerts, stall critical customer workflows, and force senior engineers to drop sprint goals just to act as manual plumbers. This "Engineering Tax" consumes up to 30–40% of development time.

We were inspired by Zentiti's mission to eliminate integration fragmentation. Instead of building another generic AI chatbot, we asked: What if our integration pipeline could self-heal in real time without crashing the app or blindly pushing unverified code?

What it does

AutoHeal.ai is an enterprise-grade, agentic AI proxy and real-time observability control plane that sits between internal microservices and external third-party APIs.

Traps API Failures: Automatically catches structural schema validation errors (400 / 422) before they crash client applications.
In-Memory Auto-Healing: Uses the Gemini API as an agentic reasoning engine to analyze the failed payload and the vendor's error trace, generate a dynamic data transformation rule, and replay the HTTP request in-memory within seconds.
Privacy-First Processing: Sanitizes and redacts all PII locally before sending payload structures to the LLM, ensuring strict data governance.
Human-in-the-Loop (HITL) Dashboard: Provides developers with an observability control plane featuring live transaction metrics, execution logs, and an AI-generated side-by-side code diff with a single-click "Approve Pull Request" button.

How we built it

We built AutoHeal.ai using a decoupled microservice architecture:

The Middleware Interceptor: Built with Node.js/Express, acting as a lightweight proxy routing outbound requests and trapping schema validation exceptions in a try/catch wrapper.
Agentic Reasoning Engine: Integrated Google Gemini API to operate in a ReAct (Reason, Act, Observe) loop. The agent analyzes structural deltas and outputs a localized data transformation.
Isolated Execution Sandbox: Used Node's vm module to execute AI-generated data mapping transformations in a safe, sandboxed environment before replaying the API request.
Observability Control Plane: Built a frontend with React and Tailwind CSS featuring a live terminal log stream, business metrics counters, and an interactive side-by-side Git diff viewer.
Mock Payment Gateway: Built a standalone mock vendor API with an "Admin Schema Drift Switch" to simulate real-world API updates live on stage.

Challenges we ran into

1. The Latency Overhead

Calling an LLM inside the synchronous hot path of an HTTP request adds latency. If the recovery latency takes too long, client applications hit SLA timeouts:

$$T_{\text{recovery}} = T_{\text{detection}} + T_{\text{inference}} + T_{\text{execution}} \ll T_{\text{human_remediation}}$$

Solution: We implemented an in-memory asynchronous strategy cache. Once Gemini successfully heals a specific API drift pattern, the proxy caches the transformation logic, reducing subsequent healed requests to an $O(1)$ local lookup that takes under 5 ms.

2. Preventing Non-Deterministic Hallucinations

LLMs can occasionally return invalid JSON syntax or incorrect field mappings.

Solution: Before replaying a healed payload to the external API, the transformed payload is run through strict local schema validation. If validation fails, the agentic loop catches the syntax error and re-prompts the model with the execution trace.

3. Security & Prompt Injection

External error strings from untrusted APIs could theoretically contain malicious injection attempts.

Solution: We decoupled values from structures. We strip out all raw user data strings and feed only structural schema keys into the prompt context window.

Accomplishments that we're proud of

Zero-Downtime Recovery: Successfully demonstrated an e-commerce checkout flow recovering from a live 422 API drift error in under 2 seconds without the user ever seeing a failure screen.
Developer-Centric Safety: Built a true Human-in-the-Loop architecture that balances instant runtime mitigation with developer code-review compliance.
Standalone Mock Environment: Created a fully functional interactive simulation that lets anyone test API drift and auto-healing in a single browser window.

What we learned

Agentic Loops vs. Simple Prompting: We learned how to move beyond basic LLM prompt-response patterns into true Agentic workflows—where the AI reasons, acts inside an execution sandbox, observes output errors, and self-corrects.
Middleware Networks: Gained a deeper understanding of asynchronous network interception, stack-trace extraction, and AST parsing.
Designing for Enterprise AI: Learned that enterprise judges don't want autonomous AI pushing code blindly to production; they want total observability paired with intelligent automation.

What's next for AutoHeal.ai

RAG for OpenAPI Specs: Implementing vector search across 5 MB+ Swagger/OpenAPI documentation files to heal complex, deeply nested enterprise endpoints.
Native CI/CD Integrations: Building GitHub Actions and GitLab CI plugins so approved hotfixes automatically generate branch pull requests and trigger unit testing suites.
Multi-Language Runtimes: Expanding the execution sandboxes to support Go, Python (Django/FastAPI), and Java Spring Boot microservices natively.