GhostFix - Autonomous Resolution Agent

Inspiration

In enterprise SaaS, the gap between a customer reporting a bug and an engineer deploying a fix is a massive black hole of productivity. Product Managers and SREs drown in support tickets, while frustrated users wait days for simple module fixes just because of weekly engineering rotation schedules.

The hackathon theme "Everyone Ships Now" inspired a pivot in our thinking: Why should rapid shipping only apply to new features? What if the support desk could ship fixes instantly? We realized that most common module errors have historical, known resolutions. We wanted to build a tool that shifts the paradigm from passive issue tracking to active, autonomous resolution keeping the user completely unblocked while the core engineering team sleeps.

What it does

GhostFix is an end-to-end autonomous resolution agent and SRE command center. It acts as a real-time bridge between customer support and engineering infrastructure.

Here is the complete shipped workflow:

Authentication & Organization: Users securely log in and can create or join Teams. Within a team, they define specific Modules (e.g., Frontend, Backend) and connect their respective GitHub repositories. A persistent green "Repo Connected" status and redirect button ensure engineers always have 1-click access to the codebase.

Smart Routing: When a user raises a ticket, they select the impacted Team and Module, and provide the issue description.

The Triage & Resolution Engine: GhostFix first checks its self-updating Knowledge Base for historical fixes. If a match is found, it instantly generates a temporary "Ghost" hotfix environment for the user to test.

Autonomous Code Generation & PRs: If the issue is entirely new and has no historical fix, the AI reads the connected module's codebase, generates the real code to fix the bug, and autonomously opens a literal, code complete Pull Request in the main GitHub repository.

Continuous Learning: Once an engineer reviews, tests, and accepts the PR, GhostFix ingests that resolution into its Knowledge Base, ensuring it learns from every new support ticket and never has to manually solve the same problem twice.

How we built it

We architected GhostFix as a modern, multi-tenant SaaS application to handle rapid incident ingestion and real-time GitHub integration.

The Core Platform: Built with Next.js (App Router), Tailwind CSS, and Shadcn UI. We implemented full user authentication and a relational database schema to handle Team management, Module routing, and user permissions.

The GitHub Integration: We built a secure OAuth/API pipeline that allows team leads to link specific repositories directly to GhostFix modules, enabling the platform to read code and push commits autonomously.

The AI Orchestrator: We utilized Claude to power the core logic. It evaluates the semantic similarity of incoming tickets against our continuous-learning ledger. If it needs to write new code, it formats a valid Git patch and interacts with the GitHub API to open the PR.

Autonomous Observability (Novus): To ensure our generated environments actually worked, we integrated Novus.ai directly into our codebase. Novus maps our routes and provides real-time behavioral tracking, allowing us to monitor user sessions within the live Ghost environments to ensure the hotfix actually resolved their friction.

Challenges we ran into

Our biggest challenge was shifting from "generative text" to "generative operations." Getting an LLM to accurately write code is one thing; getting it to properly format that code into a valid Git patch, target the correct branch, and open a clean Pull Request via the GitHub API without breaking the main repository was incredibly complex.

Additionally, managing the logic for the continuous-learning Knowledge Base required strict guardrails. We had to ensure that the AI only "learned" from PRs that were explicitly accepted and merged by human engineers, preventing hallucinated or faulty code from polluting the historical ledger.

Accomplishments that we're proud of

We are incredibly proud of achieving true Product-Market Fit for an internal tooling concept. GhostFix isn't just a clever wrapper around an API; it addresses a fundamental organizational nightmare by offering a full suite of team management and module routing tools.

We are also exceptionally proud of the sheer "Shippedness" of the product. By successfully integrating real GitHub Actions, live PR generation, and Novus observability, we proved that we can deploy an autonomous agent that not only builds a fix but tracks whether that fix was successful.

What we learned

Integrating Novus.ai taught us that observability must be active, not passive. Product analytics shouldn't just be a dashboard a PM checks on Fridays; it should act as the nervous system for your AI agents.

We also learned that LLMs are profoundly effective operators when given structural boundaries. By forcing the AI to strictly categorize its actions by Team and Module, its code generation accuracy skyrocketed compared to giving it open-ended access to an entire monolithic repository.

What's next for GhostFix - Autonomous Resolution Agent

Now that the core GitHub PR generation and continuous learning loops are live, the next step is Automated Rollbacks powered directly by Novus.

If Novus detects that a user is experiencing high friction (e.g., rage clicks or dead ends) inside a newly generated Ghost environment, GhostFix will instantly roll back the patch, invalidate the URL, automatically close the open GitHub PR, and escalate the ticket to a senior engineer. Furthermore, we plan to integrate webhooks for internal communication tools so tickets can be ingested directly from chat interfaces, bypassing the standard dashboard entirely.

Please use this email,password for Admin admin@ghostfix.com ghostfix@ad123

Built With

• github-api
• groq
• llama
• next.js
• novus
• oauth
• postgresql
• rag
• react
• supabase
• typescript
• vercel