Abstract

Recent advancements in large language models (LLMs) have opened new avenues for automating software development tasks. This paper presents a novel multi-agent system built using LangGraph, a graph-based workflow orchestration framework, integrated with OpenAI’s GPT-4 model. The system processes natural language queries to generate, debug, and explain Python code, offering a seamless interface via Gradio for user interaction.

We demonstrate the agent’s capabilities through case studies involving:

• Code generation (e.g., palindrome checking).
• Code execution (e.g., Fibonacci computation).
• Code explanation with structured outputs.

Experimental results highlight the system’s efficiency and accuracy, with iterative approaches outperforming recursive ones in runtime performance. This work contributes to AI-assisted programming by introducing a modular, extensible architecture for LLM-driven coding assistance. Limitations such as dependency on predefined workflows are discussed, with future enhancements proposed for adaptive query handling and broader language support.

Methodology

The proposed system is built on a multi-agent architecture, where each agent handles a distinct phase of the coding workflow, orchestrated using LangGraph.

Key Components

1. Query Parsing Agent

   • Interprets natural language queries (e.g., “generate a Python function for palindrome checking”).
   • Corrects misspelled inputs and ensures query consistency.

2. Code Generator Agent

   • Uses GPT-4 to generate executable Python code based on the parsed query.
   • Produces functionally correct and syntactically valid code snippets.

3. Debugger Agent

   • Evaluates the generated code for syntax errors and runtime issues.
   • Ensures correctness before execution.

4. Documentation Agent

   • Generates Markdown-formatted explanations of the code’s logic and usage.
   • Provides human-readable output for users.

Workflow Execution

• The user submits a query through the Gradio interface.
• The query is routed through LangGraph, triggering sequential processing by different agents.
• The system returns Python code, execution results, and structured explanations.

Design Considerations

• Modularity: Independent agents allow easy expansion (e.g., adding an optimization agent).
• Execution Capability: Unlike tools like GitHub Copilot, this system executes code and returns results.
• Interactivity: The Gradio UI provides a real-time coding assistant for users.

Results

The system was tested on three key tasks:

1. Code Generation

• Successfully generated a palindrome checker for various test cases.

2. Code Execution

• Evaluated the performance of recursive vs. iterative Fibonacci algorithms.
• Iterative approach significantly outperformed the recursive method in runtime efficiency.

3. Code Explanation

• The Markdown-based code explanations were coherent and user-friendly.

Key Findings

• The multi-agent approach enhances accuracy and modularity in AI-assisted programming.
• The system outperforms traditional AI coding assistants in flexibility and execution.
• Future work will focus on adaptive learning, better error handling, and support for additional languages.