CONDUCTOR

• 

  Conductor logo

Inspiration

Modern codebases are no longer written line-by-line by a single developer. Increasingly, they are generated, modified, and maintained by AI agents—each operating with partial context, making local decisions, and evolving the system over time.

But our tools haven’t caught up.

We still use IDEs designed for humans editing static files, while the reality is that codebases are becoming multi-agent systems—dynamic, distributed, and constantly changing.

We built CONDUCTOR to embrace this shift.

What if the IDE wasn’t just for writing code—but for observing, coordinating, and guiding the agents that write it?

What it does

CONDUCTOR is an agent-native IDE that turns your codebase into a living, interactive system map, while actively solving GitHub issues using AI agents.

• It visualizes code as a multi-layered architecture graph (Packages → folders → files → functions → code)
• It automatically maps relationships: (imports, references, calls, dependencies)
• It connects to your repository and ingests GitHub issues
• It shows agent activity directly on the architecture (active work areas are highlighted in real time)

Instead of manually implementing tasks, you assign issues and watch agents build the system in real time.

How we built it

We built CONDUCTOR as an extension of a cloned VS Code workbench, redesigned for agent-first workflows.

• Graph-first interface : A zoomable, multi-resolution architecture canvas Nodes represent entities (files, functions, agents), Edges represent relationships (imports, calls, ownership)
• GitHub issue ingestion layer : Parses issues into structured, executable tasks and feeds them into the agent system
• Agent orchestration layer : Main agent acts as a coordinator, Subagents are dynamically created based on issues and tasks.Each agent is assigned a working scope in the graph
• Agent visualization system : Territories, highlights, and activity overlays.

Challenges we ran into

Understanding agent-generated code : Agents produce code that is correct but often structurally inconsistent Maintaining a coherent global view : Multiple agents working in parallel can fragment the architecture Translating GitHub issues into execution : Converting vague or high-level issues into precise, solvable tasks Visualizing concurrency : Showing multiple agents operating simultaneously without overwhelming the user Trust and control : Designing a system where users can confidently allow or restrict agent actions Scaling the graph : Large, agent-generated systems grow rapidly and unpredictably

Accomplishments that we're proud of

• Reframing the IDE as a control surface for agent-driven development
• Turning GitHub issues into automated, agent-executed workflows
• Making agent activity visible, traceable, and understandable
• Creating a living architecture map instead of a static file tree
• Bridging the gap between system design, issues, and execution

What we learned

• Agent-written code requires system-level visibility, not file-level inspection
• Developers shift from writing code to supervising intent and execution
• GitHub issues become a natural interface for driving development through AI
• Transparency is critical—agents must be observable to be trusted
• Codebases are evolving into distributed systems of decisions
• The IDE of the future is less about editing and more about orchestration

What's next for CONDUCTOR

• Expanding parallel agent execution : Allow more agents to work simultaneously across different parts of the codebase. Improve coordination so parallel work remains consistent and conflict-free
• Optimizing graph generation : Faster, incremental updates to handle large and rapidly changing codebases.Smarter pruning and clustering to reduce noise and improve readability
• JIRA integration: Ingest and prioritize tasks directly from JIRA in addition to GitHub.Map tickets to affected areas in the architecture graph
• Change the grass according to the seasons

Built With

• claude
• elk
• gemini
• github
• typescript
• vscode