Helix

An autonomous AI agent that diagnoses failed GitHub Actions, generates evidence-backed fixes with NVIDIA Nemotron, validates them in Docker, and opens pull requests.

Comment

Inspiration

CI failures are expensive because engineers often spend more time gathering evidence than fixing the underlying issue. Helix was built to turn a failed GitHub Actions run into an explainable, validated fix while keeping humans in control of sensitive changes.

What it does

When a workflow fails, Helix:

  • Receives the GitHub webhook and gathers logs, commit diffs, and dependency manifests
  • Runs specialist log, code-diff, and dependency agents in parallel
  • Produces an evidence-based root-cause diagnosis with supporting references and a confidence score
  • Routes each task to an appropriate NVIDIA Nemotron model through Nebius Token Factory
  • Generates a unified-diff patch and validates it in an isolated Docker sandbox
  • Re-analyzes new validation errors and retries with an improved strategy
  • Opens a pull request when validation succeeds, or escalates when uncertainty remains
  • Streams the full agent trace to a real-time dashboard

How we built it

Helix uses a FastAPI and asyncio backend with specialist agents for log analysis, code analysis, dependency analysis, diagnosis, patch generation, correction, and verification. NVIDIA Nemotron models are accessed through Nebius Token Factory with runtime authentication, retry and error handling, model routing, and per-call usage tracking.

The backend integrates with GitHub Actions and the GitHub API, stores run state and reusable failure memory in SQLite, and executes candidate fixes in Docker. A React, Vite, and Tailwind dashboard receives live WebSocket events and displays evidence, agent progress, patches, sandbox results, pull requests, and confidence.

Technical differentiation

  • Evidence-based root-cause analysis grounded in logs, stack traces, diffs, and dependency manifests
  • Multi-model routing for efficient log triage and stronger debugging or patch generation
  • Autonomous self-correction when a generated patch fails validation
  • Regression validation before a pull request is opened
  • Confidence scoring based on evidence quality, validation results, and remaining uncertainty
  • Failure memory that can retrieve relevant solutions from previously resolved incidents
  • Safety guardrails that block dangerous commands, isolate execution, and require approval for sensitive changes

Challenges we ran into

The hardest problems were separating trustworthy evidence from noisy CI output, safely applying model-generated patches, and designing a retry loop that learns from validation failures instead of repeating the same approach. We also needed observable model routing so latency, token usage, retries, and errors could be audited.

Accomplishments that we're proud of

We built an end-to-end correction pipeline rather than a single-prompt demo: parallel investigation, evidence synthesis, model-routed patch generation, isolated validation, self-correction, human approval gates, and GitHub pull-request creation all work as one system.

What we learned

Reliable agentic debugging depends on evidence, constrained execution, and verification. Model capability matters, but orchestration, observability, and explicit safety boundaries are what make the result useful in a real engineering workflow.

What's next for Helix

Next steps include hosted deployment, support for additional CI providers, a larger evaluation suite of real-world failures, organization-level policies, and richer failure-memory retrieval.

Built With

Share this project:

Updates