Landing Page
Landing Page
The Console
Monaco Editor

AccessOps: A Collaborative Hackathon Journey

Inspiration

In modern engineering teams, CI/CD pipelines are fantastic at catching problems—but they are terrible at fixing them. We observed that developers spend countless hours acting as the glue between static analysis tools, security scanners, and their version control systems. We asked ourselves: "What if we could turn passive observability into active, autonomous remediation?"

We were inspired by the rapid evolution of Agentic AI and the release of Gemini 2.5 Pro, which possesses unparalleled reasoning capabilities. We wanted to build a "God‑Mode" SRE (Site Reliability Engineering) cockpit—a fully autonomous orchestration layer that doesn't just ping developers on Slack when a vulnerability is found, but actually writes the fix, commits it, and documents the resolution completely hands‑free.

What it does

AccessOps is an autonomous, multi‑agent orchestration platform that acts as a 24/7 AI DevOps engineer for your team.

When a developer opens a Merge Request in GitLab, it triggers the AccessOps backend hosted on Google Cloud Run. The Orchestrator agent (powered by Gemini 2.5 Pro) awakens, pre‑fetches the modified files, and spins up three specialized sub‑agents:

Security Agent: Scans for and patches XSS vulnerabilities and exposed secrets.
Accessibility (A11y) Agent: Ensures WCAG compliance by injecting ARIA labels and alt‑text without breaking existing layouts.
Performance Agent: Optimizes component rendering and asset delivery.

Instead of merely suggesting fixes, the Orchestrator uses the Model Context Protocol (MCP) to autonomously push the sanitized, compliant code directly back to the developer's branch and leaves a professional summary comment on the MR. All of this is visualized in real‑time on a breathtaking React dashboard featuring a live "Thought Stream" terminal, an interactive Agent Flow graph, and a Monaco side‑by‑side diff editor.

How we built it

AI Core: We utilized the Google GenAI SDK to harness Gemini 2.5 Pro's immense context window and tool‑calling capabilities.
Tooling Protocol: We implemented the bleeding‑edge Model Context Protocol (MCP) via the official GitLab MCP server, allowing Gemini to seamlessly read, modify, and commit code directly to our repository.
Backend Architecture: A robust Node.js/Express server wrapped in Socket.io, deployed natively on Google Cloud Run using Docker.
Frontend Dashboard: A highly dynamic, glassmorphism‑styled React 19 application built with Vite. We integrated @xyflow/react for visualizing the live agent topology and @monaco-editor/react to provide dynamic, branch‑aware code diffs of the autonomous remediations.
Compliance: We tied in Google Workspace APIs (Sheets & Docs) using Service Accounts to autonomously log telemetry and generate compliance reports for every resolved incident.

Challenges we ran into

The Recursive Webhook Loop: When our Agent pushed a fix to the MR, GitLab fired another webhook, triggering the Agent again in an infinite loop. We engineered a robust "Anti‑Loop Guardrail" that checks the author and commit signature (e.g., AccessOps: Auto‑Remediation) via the GitLab API before spinning up the orchestrator.
MCP Schema Validation Bugs: The official GitLab MCP server had strict Zod schema validations that crashed when Gemini passed missing optional parameters. Instead of abandoning MCP, we built a custom Node.js child‑process interceptor (mcpWrapper.cjs) that parses and patches the JSON inputSchema streams in real‑time before they reach the orchestrator.
Cloud Run Network Timeouts: Dynamically pulling the MCP server via npx at runtime caused connection timeouts due to Cloud Run's ephemeral scaling. We resolved this by explicitly bundling the MCP server into our Docker image at build‑time.
Remote‑Workspace WebSocket Routing: Hard‑coding io('http://localhost:3000') caused the UI to contact the wrong host when the browser ran on a local machine and the backend on a remote VM. Switching to a relative io() call and configuring Vite’s proxy (/api and /socket.io) fixed the issue and allowed seamless development.
Orphaned Socket Instance: A stray const socket = io(); at the top of App.tsx kept spawning hidden connections during React’s Strict Mode reloads. A teammate spotted the extra connections in the network tab, and we removed the dead line. Now we maintain a single socket via the useRef pattern.
Google Service‑Account Policies Bite: After wiring up the compliance reporting, GCP threw a constraints/iam.disableServiceAccountKeyCreation error. The only fix was to get an org‑admin to create an exception for our project – a reminder that real‑world deployments have organizational guardrails beyond code.

Accomplishments we’re proud of

Successfully orchestrating a multi‑agent workflow that is truly autonomous (achieving Level 5 autonomy in our pipeline).
Building an incredibly polished, "wow‑factor" God‑Mode dashboard that visualizes the AI's internal reasoning (the terminal stream) alongside tangible code diffs in real‑time.
Handling edge cases gracefully: if a file is deleted or missing, the agent catches the 404 error and leaves a human‑readable comment on the MR rather than crashing.
Each MR saves roughly 45 minutes of manual remediation – across a ten‑person team that translates to over 7 hours saved per MR cycle.

What we learned

MCP is the future for hooking LLMs into external data sources, but it demands strict schema handling and custom interceptors.
Prompt boundaries matter. We had to engineer the system prompt carefully to ensure the agent only fixes vulnerable lines and never hallucinates unrelated UI or CSS changes.
Anti‑loop engineering is non‑negotiable – any autonomous system must enforce explicit guardrails to avoid self‑triggered cascades.

What’s next for AccessOps

We plan to introduce a Pinecone Vector Database to ground the agents in specific company design systems and custom architecture rules via Retrieval‑Augmented Generation (RAG). Furthermore, we aim to expand the MCP layer to support GitHub and Bitbucket, transforming AccessOps into a truly universal, platform‑agnostic SRE engineer.

— Harshit and Tanish