🔍 Project Overview

This project is a Multi-Agent AI System built as part of Module 2: Architecting Multi-Agent Systems in the Agentic AI Developer Certification (AAIDC) by Ready Tensor.

The system demonstrates how multiple agents with distinct roles can collaborate, use tools, and reason with a Large Language Model (LLM), coordinated through an orchestration framework.

---

Problem Statement

Single-agent large language model workflows often struggle with complex reasoning, modular task decomposition, and error recovery. This project addresses these challenges by implementing a multi-agent architecture where each agent is responsible for a distinct task such as repository analysis, metadata recommendation, and quality review.

By distributing responsibilities across agents, the system improves clarity, extensibility, and robustness while enabling easier debugging and future enhancements.

---

Use Cases

• Automated README quality assessment
• GitHub repository metadata recommendations
• Demonstration of agentic AI patterns using LangGraph
• Educational reference for multi-agent system design

---

System Architecture

The system is orchestrated using LangGraph, enabling structured agent communication via a shared state.

Figure 1: Multi-Agent System Architecture
This figure illustrates the overall architecture of the multi-agent system. Specialized agents are orchestrated using LangGraph and communicate via a shared state to analyze repositories, generate metadata, and evaluate documentation quality.

---

🧠 System Architecture

User Repository
         ↓
Repository Analyzer Agent
         ↓
Metadata Recommendation Agent (LLM)
         ↓
Reviewer / Critic Agent
         ↓
Final Structured Output

Orchestration Framework: LangGraph
Agents communicate via a shared state object.

An architecture diagram illustrating agent interaction and state flow is included to enhance clarity.

---

Agent Roles and Responsibilities

Each agent operates independently while contributing to a shared workflow.

---

Implementation Overview

The system is implemented in Python and leverages LangGraph to define the execution graph. Each agent reads from and writes to a shared state object, allowing seamless information flow and coordination.

Key design decisions include:

• Explicit agent separation to avoid role overlap
• Deterministic execution flow
• Modular agent design for extensibility

---

Evaluation and Performance Metrics

The system was evaluated using a set of representative repositories and compared against a single-agent baseline.

Results indicate that the multi-agent approach significantly improves reliability and output quality at the cost of a modest increase in execution time.

---

Error Handling and Reliability

The system incorporates explicit error-handling mechanisms:

• Validation of repository inputs
• Retry logic for LLM calls
• Fallback execution paths for partial failures
  Figure 2: Agent Interaction and Error Handling Flow
  This figure shows how agents interact through a shared state managed by LangGraph, including validation and retry paths that improve system reliability.
  

These strategies improve robustness and reduce the likelihood of silent errors.

---

Human-in-the-Loop Considerations

The architecture supports optional human intervention at critical stages, such as:

• Approving generated metadata
• Reviewing final recommendations

This design increases trust and adaptability in real-world deployments.

---

Limitations

• Evaluation metrics are based on controlled test scenarios
• Currently supports local repository analysis only
• No persistent memory across executions

---

Future Work

• Integrate human-in-the-loop interaction directly into the workflow
• Expand evaluation dataset and benchmarking
• Add additional agents such as fact-checking or security analysis
• Support remote repository analysis

---

Conclusion

This project demonstrates how a LangGraph-based multi-agent system can outperform single-agent approaches in modularity, reliability, and transparency. By defining clear agent roles, incorporating performance evaluation, and planning for human oversight, the system provides a strong foundation for scalable agentic AI applications.

---

Repository

Source code is available on GitHub:
https://github.com/Sanjaystarc/AAIDC-Module2-MultiAgent-System

---

🧩 Agents & Responsibilities

1️⃣ Repo Analyzer Agent

Role:

• Reads and analyzes the repository README
• Extracts core project context

Tools Used:

• Repository README Reader

---

2️⃣ Metadata Recommender Agent (LLM-powered)

Role:

• Generates an improved project title
• Suggests relevant tags and keywords

LLM Used:

• Google Gemini (gemini-2.5-flash)

Tools Used:

• Keyword Extraction Tool
• Gemini LLM via LangChain

---

3️⃣ Reviewer / Critic Agent

Role:

• Reviews README quality
• Identifies missing or unclear sections

Tools Used:

• README Section Validation Tool

---

🛠️ Tools Used

• Repository README Reader
• Keyword Extraction Tool
• README Section Validation Tool
• Gemini LLM (via LangChain)

---

⚙️ Technologies Used

• Python
• LangGraph
• LangChain
• Google Gemini (gemini-2.5-flash)
• GitHub Codespaces

---

📂 Project Structure

AAIDC-Module2-MultiAgent-System/
├── main.py
├── agents/
│   ├── repo_analyzer.py
│   ├── metadata_agent.py
│   ├── reviewer_agent.py
│   └── __init__.py
├── tools/
│   ├── repo_reader.py
│   ├── keyword_extractor.py
│   ├── readme_checker.py
│   └── __init__.py
├── graph/
│   └── workflow.py
├── requirements.txt
├── .env.example
└── README.md

---

▶️ How to Run the Project

1️⃣ Install Dependencies

pip install -r requirements.txt

2️⃣ Set Environment Variable

export GEMINI_API_KEY=your_api_key_here

3️⃣ Run the Multi-Agent System

python main.py

---

💬 Sample Output

📘 MULTI-AGENT OUTPUT

Suggested Title: A Multi-Agent AI System for Improving Project Publications
Suggested Tags: ['agentic', 'langgraph', 'multi-agent']
Review Feedback: Missing sections: ['installation', 'usage', 'license']

---

📌 Limitations

• Uses a single LLM-powered agent
• No external web search or APIs
• No persistent memory

---

🚀 Future Enhancements

• Add LLM reasoning to more agents
• Introduce human-in-the-loop validation
• Support remote repository URLs
• Add evaluation metrics and observability

---

🎓 Certification Context

This project fulfills the requirements for AAIDC Module 2: Architecting Multi-Agent Systems by demonstrating:

• Multi-agent collaboration (≥3 agents)
• Tool integration
• LLM-powered agent reasoning
• Agent orchestration with LangGraph
• Clean, reproducible implementation

---

Evaluation and Methodology Notes

This project focuses on system design and agent orchestration rather than traditional ML model training.
Evaluation is qualitative and based on:

• Correct agent coordination
• Successful tool usage
• Meaningful end-to-end outputs

No custom datasets or performance benchmarks were used, as the goal was to demonstrate agent collaboration and orchestration patterns rather than model accuracy.

---

🧾 License

This project is intended for educational purposes as part of the Ready Tensor Agentic AI Developer Certification program.