OSC-Agent — Open Source Contributing Agent

OSC-Agent is an autonomous AI agent that uses Gemini to analyze GitHub issues, search codebases, generate fixes, verify them in isolated sandboxes, and submit high-quality pull requests automatically.

Comment

Inspiration

Open source is full of small-but-important issues, but the path from “issue description” to a verified pull request is still slow and repetitive: read the issue, find the right files, implement a fix, run tests, write a PR description, and link everything back to the issue. OSC-Agent was inspired by the idea that an AI agent should be able to behave like a real open-source contributor from the terminal — not just generate code, but prove the fix works and package it into a clean PR.

What it does

OSC-Agent is an autonomous CLI system that:

  • Fetches and analyzes GitHub issues and extracts requirements/context.
  • Performs “surgical” codebase search using ripgrep to locate the most relevant code sections.
  • Uses a Gemini-powered multi-agent workflow to draft candidate fixes.
  • Runs tests in an isolated E2B sandbox and iterates with self-correction loops until the fix is verified.
  • Automatically creates a well-documented pull request linked back to the original issue. :contentReference[oaicite:1]{index=1}

How we built it

We designed OSC-Agent as a modular, graph-based workflow: 1) GitHub API integration to discover and fetch issues
2) Issue Analyzer to understand intent and constraints
3) Code Search module (ripgrep) for fast, context-aware retrieval
4) Multi-agent Fix Generator (Gemini) for patch generation
5) E2B Sandbox Testing for safe execution + validation + iteration
6) PR Creator to publish changes with clear descriptions and issue references :contentReference[oaicite:2]{index=2}

We also added “model routing” so simpler tasks can be handled by cheaper Gemini tiers while complex changes use stronger models, improving cost efficiency. :contentReference[oaicite:3]{index=3}

Challenges we ran into

  • Getting reliable context from issues: issue descriptions vary widely in clarity and completeness.
  • Avoiding “over-editing”: the agent must change the minimum necessary lines to fix the bug.
  • Verification loops: ensuring tests run deterministically in a sandbox and that failures produce actionable feedback for the next iteration.
  • Robust orchestration: building a graph/state-machine style workflow that can recover cleanly from errors and partial failures. :contentReference[oaicite:4]{index=4}

Accomplishments that we're proud of

  • End-to-end pipeline design: issue → code search → patch → sandbox tests → PR creation.
  • Safety-first verification via isolated E2B sandboxes and iterative self-correction.
  • A clear modular architecture that can be extended (more agents, richer review, metrics). :contentReference[oaicite:5]{index=5}

What we learned

  • In agentic systems, orchestration and evaluation matter as much as the LLM.
  • “Fast retrieval + strong constraints” (ripgrep + scoped edits) significantly improves code-fix reliability.
  • Automated verification is the difference between “code generation” and “real contribution.”

What's next

  • Deeper code review integration (linting, style checks, PR review suggestions).
  • Multi-language support and better repository-specific configuration.
  • Collaboration features and a metrics dashboard to track agent performance over time.
  • Self-hosted deployment options for teams. :contentReference[oaicite:6]{index=6}

Built With

+ 3 more
Share this project:

Updates