Autonomous Software Agency

An AI-powered multi-agent system that builds complete software applications from product briefs. Built for the Gemini 3 Hackathon.

Overview

The Autonomous Software Agency is a swarm of specialized AI agents that collaborate to build software from a single product description. Using Google's Agent Development Kit (ADK), MCP (Model Context Protocol), and A2A (Agent-to-Agent Protocol), the system demonstrates the power of autonomous AI agents working together.

Key Features

• Multi-Agent Collaboration: 7 specialized AI agents working together
• End-to-End Development: From requirements to deployment
• Protocol-Based Communication: A2A protocol for inter-agent messaging
• Rich Tool Integration: MCP servers for GitHub, terminal, browser automation
• Real-Time Progress Tracking: Watch agents collaborate in real-time

AI Agents

Agent	Role	Responsibilities
Orchestrator	Team Lead	Coordinates agents, manages project flow
Product Manager	Requirements	Creates PRD, user stories, acceptance criteria
System Architect	Design	Architecture, database schemas, API specs
Frontend Developer	UI	React/Next.js implementation
Backend Developer	API	FastAPI backend, database logic
QA Engineer	Testing	Test plans, bug reports, validation
DevOps Engineer	Deployment	CI/CD, infrastructure, deployment

Technology Stack

• Agent Framework: Google ADK (Agent Development Kit)
• AI Model: Gemini 3 Pro / Flash
• Tool Protocol: MCP (Model Context Protocol)
• Agent Communication: A2A (Agent-to-Agent Protocol)
• UI: Gradio

Project Structure

autonomous-software-agency/
├── src/
│   ├── agents/           # AI agent definitions
│   │   ├── orchestrator.py
│   │   ├── pm_agent.py
│   │   ├── architect_agent.py
│   │   ├── frontend_agent.py
│   │   ├── backend_agent.py
│   │   ├── qa_agent.py
│   │   └── devops_agent.py
│   ├── a2a/              # A2A protocol implementation
│   │   ├── messages.py
│   │   └── handler.py
│   ├── mcp_servers/      # MCP tool servers
│   │   ├── github_server.py
│   │   ├── terminal_server.py
│   │   ├── browser_server.py
│   │   └── filesystem_server.py
│   ├── tools/            # Tool integrations
│   ├── utils/            # Utilities
│   ├── config.py         # Configuration
│   └── main.py           # Entry point
├── ui/
│   └── app.py            # Gradio web interface
├── tests/                # Test suite
├── requirements.txt
└── README.md

Installation

Prerequisites

• Python 3.11+
• Google API Key (for Gemini)
• GitHub Token (optional, for repo creation)

Setup

1. Clone the repository:

git clone https://github.com/MuhammadAbdullah95/autonomous-software-agency.git
cd autonomous-software-agency

2. Create a virtual environment:

python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# or
.venv\Scripts\activate  # Windows

3. Install dependencies:

pip install -r requirements.txt

4. Set up environment variables:

cp .env.example .env
# Edit .env with your API keys

5. Install Playwright browsers (for E2E testing):

playwright install chromium

Usage

Web Interface (Recommended)

python ui/app.py

Open http://localhost:7860 in your browser.

Command Line

# With a product brief
python -m src.main --brief "Build a todo app with user authentication"

# From a file
python -m src.main --brief-file product_brief.txt

# Interactive mode
python -m src.main --interactive

As a Library

import asyncio
from src.main import AutonomousSoftwareAgency

async def main():
    agency = AutonomousSoftwareAgency(project_name="MyApp")
    result = await agency.build_software("""
        Build a task management app with:
        - User authentication
        - CRUD operations for tasks
        - Due dates and priorities
    """)
    print(result)

asyncio.run(main())

Configuration

Environment variables (.env):

# Required
GOOGLE_API_KEY=your_gemini_api_key

# Optional
GITHUB_TOKEN=your_github_token
GOOGLE_CLOUD_PROJECT=your_project_id
LOG_LEVEL=INFO

How It Works

1. Product Brief → Requirements

The Product Manager analyzes your brief and creates:

• Product Requirements Document (PRD)
• User stories with acceptance criteria
• Feature prioritization (P0/P1/P2)

2. Requirements → Architecture

The System Architect designs:

• System architecture diagrams
• Database schemas
• API specifications
• Project structure

3. Architecture → Code

Frontend and Backend developers implement:

• React/Next.js components
• FastAPI endpoints
• Database models
• Authentication logic

4. Code → Testing

The QA Engineer creates and runs:

• Unit tests
• Integration tests
• E2E tests
• Bug reports

5. Testing → Deployment

The DevOps Engineer handles:

• CI/CD pipeline setup
• Environment configuration
• Deployment to cloud
• Monitoring setup

A2A Communication

Agents communicate using a custom A2A protocol:

# Task Assignment
await a2a.assign_task(
    from_agent="Orchestrator",
    to_agent="ProductManager",
    task_description="Create PRD for task management app",
    acceptance_criteria=["User stories defined", "Priorities set"]
)

# Design Decision Broadcast
await a2a.broadcast_design_decision(
    from_agent="SystemArchitect",
    decision_type="architecture",
    decision="Using FastAPI + Next.js stack",
    rationale="Best for rapid development"
)

# Bug Report
await a2a.report_bug(
    from_agent="QualityAssurance",
    to_agent="FrontendDeveloper",
    title="Login button not responsive",
    severity="medium"
)

MCP Tools

Available MCP tools for agents:

Server	Tools
GitHub	create_repository, commit_files, create_pr
Terminal	run_command, run_tests, install_dependencies
Browser	navigate, screenshot, run_e2e_test
Filesystem	create_project_structure, read_file, write_file

Development

Running Tests

pytest tests/ -v

Adding New Agents

1. Create agent file in src/agents/
2. Define instruction prompt
3. Add to __init__.py
4. Register in orchestrator's sub_agents

Adding New MCP Tools

1. Create server in src/mcp_servers/
2. Define tools with @mcp.tool decorator
3. Register in src/tools/mcp_tools.py

Demo Video

Watch the 3-minute demo

Hackathon Submission

This project was built for the Gemini 3 Hackathon.

Judging Criteria Alignment

• Technical Execution (40%): Multi-agent orchestration with MCP + A2A
• Innovation (30%): True agent collaboration, not just sequential handoffs
• Real-World Impact (20%): Automates expensive software development
• Presentation (10%): Clean UI showing agent collaboration

Gemini 3 Features Used

• Long context window for understanding full codebases
• Advanced reasoning for architecture decisions
• Tool use for MCP integration
• Multi-turn conversation for complex tasks

License

MIT License

Acknowledgments

• Google DeepMind for Gemini 3
• Google ADK team for the Agent Development Kit
• Anthropic for the MCP protocol
• The open-source community

---

Built with Gemini 3 for the Gemini 3 Hackathon