Hubble: The AI Coding Team

One task. Multiple AI coding agents. Hubble coordinates independent coding tools, reverse-engineers unfamiliar codebases, verifies changes, and learns from failures to improve future runs.

Comment

Inspiration

AI coding assistants are powerful, but complex software engineering rarely fits into a single prompt. Understanding an unfamiliar repository, investigating a bug, implementing a fix, reviewing changes, and verifying the result require different skills and perspectives.

I built Hubble to explore a better approach: what if AI coding tools could work together as a coordinated engineering team?

The vision behind Hubble is to move beyond isolated AI assistants toward a system where specialized agents collaborate, share evidence, challenge assumptions, and verify each other's work. Instead of simply generating code, the team should help developers understand problems and deliver reliable solutions.

What it does

Hubble is an open-source, Python-based agentic coding CLI designed to help developers work directly with their codebases.

Its existing capabilities support repository exploration, file operations, command execution, testing, and delegation to specialized agents. Hubble is designed to work with different LLM providers, including hosted APIs and local models.

The broader Hubble vision is to coordinate independent coding agents through a shared workflow:

  • Investigate: Understand an unfamiliar codebase and trace how its components work together.
  • Delegate: Break complex engineering tasks into smaller, specialized assignments.
  • Collaborate: Let agents contribute different analyses and implementation proposals.
  • Verify: Run tests and inspect changes before accepting a result.
  • Improve: Evaluate failed runs and experiment with workflow changes to improve future performance.

A central use case is the Reverse Engineering Agent (REA), which helps developers understand unfamiliar repositories and propose evidence-backed changes.

How we built it

Hubble is built in Python, with an architecture centered on repository-aware tool use and agent orchestration.

The project brings together LLM integrations, codebase exploration, file editing, shell commands, automated testing, and specialized agent workflows. Its design also emphasizes safer execution through configurable approvals and controlled access to development tools.

The hackathon direction builds on this foundation: coordinating independent coding-agent runtimes, preserving clear boundaries between their changes, and evaluating results through reproducible tests. The goal is to make collaboration useful and measurable rather than simply increasing the number of agents.

Challenges we ran into

One major challenge is context management. Different agents may reach different conclusions, repeat work, or misunderstand the same codebase. Effective coordination requires each agent to receive the right information without overwhelming it with irrelevant context.

Another challenge is reliability. A convincing explanation or plausible patch does not guarantee correct software. Changes need to be checked against the repository, existing behavior, and automated tests.

A third challenge is evaluation. A self-improving system should not assume that every failed run reveals a useful lesson. Workflow changes must be tested against comparable tasks, and improvements should be retained only when evidence supports them.

Accomplishments that we're proud of

We are proud to have an open-source foundation for agentic coding that works directly with real repositories rather than limiting interaction to conversational code suggestions.

Hubble brings together repository operations, model-provider flexibility, task delegation, and development-tool execution in a single workflow. It also establishes a foundation for exploring safer, more systematic collaboration between specialized agents.

Most importantly, Hubble represents a shift in perspective: AI coding should not be judged only by how much code a model generates, but also by how well the resulting changes are understood, tested, and verified.

What we learned

Building Hubble has reinforced that more agents do not automatically produce better results. Coordination, clear task boundaries, shared evidence, and verification are just as important as model capability.

We also learned that software engineering agents need access to practical tools and real execution feedback. Tests, repository structure, command outputs, and change history provide evidence that a model's reasoning alone cannot guarantee.

These lessons shaped our focus on measurable outcomes: successful task completion, test results, correctness, and the ability to reproduce improvements.

What's next for Hubble: The AI Coding Team

Our next goal is to evolve Hubble from an agentic coding CLI into a collaborative engineering harness that can coordinate independent coding-agent systems.

We plan to develop three complementary capabilities:

  1. Cross-runtime collaboration: Coordinate different coding agents through structured tasks, shared findings, and isolated code changes.
  2. Reverse Engineering Agent: Help developers map unfamiliar repositories, trace execution paths, investigate failures, and propose verified fixes.
  3. Evidence-driven self-improvement: Analyze unsuccessful runs, test alternative orchestration strategies, and retain changes only when controlled evaluations show meaningful improvement.

For the hackathon, we also aim to demonstrate an accessible, conversational developer workflow inspired by Alexa+, allowing users to request repository investigations and receive actionable findings.

Our long-term vision is simple: one engineering task, multiple specialized AI agents, and one coordinated workflow that prioritizes evidence, correctness, and continuous improvement.

Built With

Share this project:

Updates