Documentation

Why Modulo

General-purpose coding agents — Claude Code, Cursor, Gemini, Copilot — are powerful tools for writing and refactoring code. But debugging complex distributed systems requires something different: stateful, auditable, collaborative multi-agent workflows built around the full context of a production failure.

Modulo vs. Coding Agents

Closing the APM Resolution Gap

Traditional APM tools — Datadog, New Relic, Splunk, Dynatrace — alert you to problems. They stop at the critical moment: the fix. Modulo bridges that gap.

• Trace-to-Fix Pipeline — Consumes distributed traces (OpenTelemetry, Jaeger) and maps them to the specific code locations that need changing.
• Alert Enrichment — Transforms vague APM alerts into concrete fix proposals with confidence scores and evidence references.
• No More Tool Sprawl — Integrates with your existing observability stack: Datadog, New Relic, Splunk, Dynatrace, ELK Stack, Loki, CloudWatch, Grafana, PagerDuty, Opsgenie.
• Intelligent Triage — Continuous learning reduces alert fatigue by improving detection accuracy and deprioritizing false positives.

Key Differentiators

• Multimodal Input Intelligence — Integrates visual data (screenshots, screen recordings, error images) with logs, metrics, and traces to triage bugs across your full application stack.
• Data Privacy — Full Control — The VS Code extension runs fixbugs as a local process. Your code is analyzed on your machine. Supports custom LLM backends so your data never touches a third-party AI provider.
• Built for Large Context — Fan-out / fan-in agentic architecture efficiently processes massive data volumes. Up to 16× throughput through intelligent parallelization.
• Price Advantage — Supports local models and open-source alternatives like GLM 4.7 and Minimax M2.7 — no vendor lock-in.
• Built for Teams — Triage sessions are shareable and resumable. Bug ownership changes hands; Modulo keeps the full context intact.

Get Started

Choose your integration:

Prerequisites — VS Code Extension

• VS Code 1.85 or later
• An LLM API key (OpenRouter recommended)
• Git installed

Prerequisites — GitHub App

• A GitHub account
• A repository to install the App on

VSCode Extension

The Modulo VS Code extension turns your editor into a full bug triage workbench. It automatically manages a local fixbugs server, connects to Modulo's authentication service, and provides a panel-based UI that walks you from raw bug report to applied code fix.

What you get:

• Import bugs from GitHub, GitLab, Jira, APM alerts, or paste raw text
• Automatic fault localization — no manual file hunting
• Competing root-cause hypotheses with confidence scores and evidence
• Agentic streaming chat with full tool-call visibility
• Task-based fix plans with split-view source code
• Hunk-level diff review with inline accept / reject
• Apply fixes directly to your workspace; handle merge conflicts in-editor
• Create commits and open pull requests without leaving VS Code

Install: Open VS Code → Extensions → search FixBugs → Install, or use the Marketplace link.

Features & Steps

Step 1 — Ingest & Analyze

Import a bug from any source:

• Paste a GitHub / GitLab / Jira issue URL
• Paste an APM alert URL or raw alert payload
• Type or paste a bug description directly

Modulo fetches the full context: issue body, all comments, linked PRs, stack traces, error images, logs, metrics, and traces. No token ceiling — agent swarms chunkify and process arbitrarily large data volumes.

Step 2 — Hypotheses

Most debugging tools pick the single most likely cause and retry when wrong. Modulo takes a different approach: recall over precision. It generates multiple competing root-cause hypotheses, each with:

• A confidence score (0–100%)
• Evidence pointers — specific files, functions, and line references
• A suggested fix approach

You review the hypotheses and select the one that fits your understanding.

Step 3 — Assistant Chat

A familiar streaming chat interface. Ask Modulo anything about the bug, guide its reasoning, or ask it to reconsider a hypothesis. The agent shows its full reasoning chain:

• Real-time streaming text with extended thinking blocks
• Full functionality accessible via chat, from hypothesis tuning to regenerating the code changes.

Step 4 — Fix Planning

Modulo generates a structured, task-based fix plan for the selected hypothesis. The plan view shows:

• A plain-language summary of the approach
• A list of tasks, each identifying the file to change and the change needed
• Split-view: plan on the left, live source code on the right

Edit the plan inline or ask Modulo to regenerate with constraints (e.g., "make the fix more conservative", "avoid changing the public API").

Step 5 — Diff Review & Apply

Modulo generates unified diffs for every affected file. Review them at the hunk level — accept or reject individual change blocks without touching the rest of the file. Regenerate any hunk inline with guidance.

When satisfied, apply the fix to your workspace:

• Clean workspace — changes appear as unsaved edits; review before saving
• Dirty workspace — a three-way merge UI shows original, current, and proposed side by side

From there, create a commit and open a pull request — all from the VS Code panel.

Configuration

All settings are under the modulo.* namespace in VS Code settings (Ctrl+, or Cmd+,).

Connection

LLM

Database

Performance & Tuning

GitHub App

The Modulo GitHub App — github.com/apps/solve-bug — integrates directly into your GitHub issue workflow. Install it once; Modulo automatically analyzes every new issue and responds to comment commands with analysis summaries, code fixes, and pull requests.

Installation

1. Visit github.com/apps/solve-bug or search Modulo AI in the GitHub Marketplace.
2. Click Install and select repositories:
   • All repositories — Modulo monitors all current and future repos
   • Select repositories — Choose specific repos
3. Authorize the required GitHub permissions (see Webhook Configuration).
4. Verify your email to activate the account.

Automatic Behavior

The moment a new issue is opened or labeled, Modulo posts an AI-generated comment containing:

• Summary — concise description of the bug
• Classification — bug type (runtime error, API issue, logic bug, configuration error, etc.)
• Severity and priority — impact and urgency assessment
• Actionability — whether the report contains enough information to act on

Webhook Commands

Post any of the following as an issue comment to trigger Modulo's fix pipeline.

You can also use short trigger phrases anywhere in a comment:

@fixbugs fix this
@fixbugs fix
@modulo fix this
@modulo fix

Typical Workflow

1. Team member reports a bug in GitHub Issues
2. Modulo auto-posts analysis summary (classification, severity, actionability)
3. Comment: solve-bug
4. Modulo analyzes, generates fix (5–10 min), posts diffs as comment
5. Comment: solve-bug-pr
6. Modulo opens a pull request with the fix
7. Team reviews, approves, and merges

Iterative Refinement

If the first fix doesn't address the root cause, guide Modulo with context:

The issue is in the authentication middleware, not the database layer.
The session token expires before the refresh logic runs.

solve-bug-again

Modulo reruns the full analysis with your guidance as additional context.

Webhook Configuration

Configuration is done entirely through GitHub during installation — no server setup required.

Required GitHub Permissions

Trigger Events

Security: All webhook payloads are verified via HMAC-SHA256 signature before processing. Modulo never permanently stores your source code.

Architecture

Modulo's core engine — fixbugs — is a Python FastAPI service that orchestrates a multi-agent pipeline for bug resolution. The VS Code extension communicates with a local fixbugs instance over REST and WebSocket; the GitHub App triggers the same pipeline in the cloud.

VSCode Extension / GitHub Webhook
        ↓
fixbugs REST API + WebSocket
        ↓
WorkflowCoordinator
        ↓
Solver Layer (Analysis → Hypotheses → Plan → Fix)
        ↓
LLM Driver
        ↓
Repository Layer (SQLite default / PostgreSQL optional)
        ↓
Adapters (GitHub, GitLab, Jira, Prometheus, Local file, Raw text)

Specialized Agents

Performance

Modulo achieves high throughput through intelligent parallelization:

• Sequential analysis of 500KB context at 100 tok/s = 600 seconds
• 16 parallel threads at 100 tok/s each = 37.5 seconds — 16× faster
• Analysis that would take 10+ minutes completes in under 60 seconds

Supporting Services

• users — Authentication (GitHub, GitLab, Jira OAuth), GitHub App installation management, subscription entitlements, API key brokerage, session management
• MCP server integrations, like CodeGraphContext, time, context7 provides deep analysis for C, C++, Go, Java, JavaScript, PHP files and their commonly used libraries.

Pricing

Save 25% on all paid plans with annual billing. Pay-as-you-go: Pro plan users can purchase additional fix credits at API rates beyond the monthly quota.

Available via GitHub Marketplace or direct subscription (Stripe globally, Razorpay for India — auto-selected by location).

Competitive Landscape

AI SREs (Incident.io, Shoreline) handle monitoring and root-cause analysis but stop at the fix. Code assistants (Gemini, Codex, Copilot) generate fixes but require you to bring your own context and validate manually. Modulo does all three — monitor, diagnose, and fix — end-to-end with automated validation.

Account Management

Manage your Modulo account at users.fixbugs.ai.

Dashboard

• Quota monitoring — Visual progress bar showing usage vs. monthly quota; alerts at 80% and 100%; next reset date
• Usage statistics — Bugs Analyzed (all time), PRs Merged, API Calls this month
• Subscription badge — Current plan (Free Trial / Pro / Super User)
• GitHub Marketplace status — Plan name, billing cycle, next billing date, pending plan changes

API Keys

API keys authenticate the VS Code extension, CLI, and any programmatic access.

1. Dashboard → API Keys → Create New API Key
2. Give it a descriptive name (e.g., "VSCode Extension", "CI/CD Pipeline")
3. Copy the key immediately — it is shown only once
4. Store it in a password manager or environment variable; never commit to source control

Each key records its call count, last-used timestamp, and active/revoked status. Revocation via Dashboard → API Keys → Revoke is immediate and irreversible.

Billing Portal

Dashboard → Billing & Subscription:

• View and download invoices
• Update payment method
• View payment history
• Upgrade, downgrade, or cancel subscription

Upgrades take effect immediately. Downgrades apply at the end of the current billing period.

Privacy & Compliance

FAQ