How I Built DevTeam AI: A Multi-Agent Software Engineering Team Powered by QwenCloud

Turning a single product idea into a complete software delivery plan using specialized AI agents, human approval workflows, and QwenCloud.

Introduction

Large Language Models have become incredibly good at generating code, documentation, and product ideas. But there's one problem I kept running into.

Software isn't built by one person.

A successful product typically involves product managers, solution architects, backend engineers, frontend engineers, QA engineers, technical leads, and reviewers—all collaborating, challenging assumptions, and refining ideas before a single line of production code is written.

Most AI applications flatten all of these roles into a single prompt.

I wanted to explore something different.

For the QwenCloud Global AI Hackathon (Agent Society Track), I built DevTeam AI—a multi-agent software engineering platform where specialized AI agents collaborate like a real product team, complete with approvals, design reviews, negotiations, revisions, and code generation.

Rather than asking one AI assistant to do everything, DevTeam AI orchestrates an entire software delivery workflow powered by QwenCloud.

The Problem

One of the most expensive parts of software development isn't coding.

It's planning.

Anyone who has worked on production software knows the journey usually looks like this:

• Product requirements


• Architecture discussions


• API design


• Database modeling


• Frontend planning


• QA strategy


• Security review


• Technical review


• Scope negotiations


• Implementation planning

These activities often involve multiple stakeholders with conflicting priorities.

A product manager wants more features.

A backend engineer wants simplicity.

QA wants better testability.

The architect wants scalability.

The CTO worries about long-term maintainability.

Most AI tools merge all these viewpoints into one response.

I wanted to see whether AI agents could behave more like a real engineering organization.

The Idea Behind DevTeam AI

Instead of one intelligent assistant...

I built an AI software company.

Each agent has:

• A clearly defined responsibility


• Dedicated prompts


• Inputs from previous agents


• Approval dependencies


• Review responsibilities


• Conflict resolution capabilities

Rather than producing one giant response, the system produces a complete software delivery package.

Meet the AI Engineering Team

DevTeam AI currently orchestrates 11 specialized AI agents across multiple workflow stages.

1. Orchestrator Agent

Coordinates the entire workflow.

Responsible for:

• sequencing stages


• dependency validation


• workflow state


• execution monitoring

2. Product Manager Agent

Transforms a rough product idea into:

• Product Requirements Document (PRD)


• User stories


• Acceptance criteria


• MVP scope

3. Solution Architect Agent

Designs the technical foundation.

Outputs include:

• System architecture


• Component responsibilities


• Mermaid architecture diagrams


• Technology recommendations

4. Backend Engineer Agent

Designs:

• REST APIs


• Authentication


• Database schema


• Business logic


• Service structure

5. Frontend Engineer Agent

Plans:

• User flows


• UI architecture


• State management


• Component hierarchy


• Mobile/Web implementation

6. QA Engineer Agent

Produces:

• Test strategy


• Test cases


• Edge cases


• Risk analysis


• Acceptance validation

7. CTO Reviewer Agent

One of my favorite agents.

Instead of generating new work...

It challenges existing work.

It looks for:

• inconsistent assumptions


• scalability issues


• security risks


• missing requirements


• architectural weaknesses

Real engineering teams become stronger because of review—not because everyone agrees.

8. Negotiator Agent

When agents disagree...

Someone has to make a decision.

The Negotiator Agent produces:

• decision records


• trade-offs


• compromise recommendations


• rationale

This became one of the most interesting parts of the project because it mimics real technical discussions.

9. Revision Coordinator

After human feedback, this agent:

• summarizes requested changes


• coordinates revisions


• keeps documentation synchronized

10. Code Generator Agent

Once planning has been approved, this agent generates:

• starter project


• boilerplate


• folder structure


• implementation scaffold

11. Code Reviewer Agent

Performs a final review of generated code by checking:

• maintainability


• best practices


• potential bugs


• consistency

Human Approval Is Not Optional

One decision I made early was that AI should not automatically move to the next stage.

Every stage requires human approval.

The workflow looks like this:

Idea



↓



PRD



↓



Architecture



↓



Backend



↓



Frontend



↓



QA



↓



CTO Review



↓



Negotiation



↓



Revision



↓



Code Generation



↓



Code Review

If something isn't right...

The workflow stops.

The user can:

• approve


• regenerate


• request revisions

Only after approval does the next stage begin.

This small decision makes DevTeam AI feel much closer to a real engineering workflow than a traditional prompt chain.

Why I Chose QwenCloud

When building multi-agent systems, the language model quickly becomes the least interesting part.

The orchestration layer becomes the real challenge.

I wanted a model that allowed me to focus on building agent collaboration rather than spending days adapting SDKs.

QwenCloud was a natural fit.

OpenAI-Compatible API

Integration was surprisingly straightforward.

Because the API is OpenAI-compatible, I didn't need to redesign my backend.

Instead, I focused on:

• workflow orchestration


• agent prompting


• approval gates


• state management


• conflict resolution

Excellent Structured Outputs

Every agent generates structured artifacts.

Examples include:

• Markdown


• JSON


• Mermaid diagrams


• API specifications


• PRDs

Consistent formatting was extremely important because later agents depend on previous outputs.

Strong Reasoning

Many stages require analysis rather than generation.

Examples include:

• reviewing architecture


• identifying contradictions


• comparing implementation plans


• detecting missing requirements

These reasoning-heavy tasks are where QwenCloud performed particularly well.

Perfect for Multi-Agent Workflows

A multi-agent system might invoke the model dozens of times for one project.

Each call has different objectives.

Some agents create.

Others critique.

Others summarize.

Others negotiate.

QwenCloud handled these role-specific prompts reliably throughout development.

System Architecture

The architecture intentionally keeps the infrastructure simple while making the workflow sophisticated.

                 User

                   │

          Next.js Frontend

                   │

        Server-Sent Events

                   │

             FastAPI Backend

                   │

        Workflow Orchestrator

                   │

     ┌────────────────────────┐

     │ Product Manager        │

     │ Architect              │

     │ Backend                │

     │ Frontend               │

     │ QA                     │

     │ CTO                    │

     │ Negotiator             │

     │ Revision               │

     │ Code Generator         │

     │ Code Reviewer          │

     └────────────────────────┘

                   │

             QwenCloud API

                   │

               SQLite

Technology Stack

Frontend

• Next.js


• TypeScript


• Tailwind CSS

Backend

• FastAPI


• Python


• SQLite


• HTTPX

AI

• QwenCloud


• OpenAI-compatible Chat API

Real-Time Updates

• Server-Sent Events (SSE)

Export

• ZIP generation


• Markdown artifacts

Why I Used Server-Sent Events Instead of WebSockets

Many AI demos use WebSockets.

For DevTeam AI, Server-Sent Events were a better fit.

The application mainly streams:

• agent progress


• stage updates


• logs


• completion events

Communication is almost entirely server → client.

SSE provided:

• simpler implementation


• automatic reconnection


• lower overhead


• easier deployment behind Nginx

Sometimes the simpler solution is the better engineering choice.

One Feature I'm Particularly Proud Of

One feature I added late in development dramatically improved the user experience.

As more workflow stages were added, the interface became overwhelming.

I redesigned the workspace so that:

• only the active workflow expands automatically


• completed stages collapse


• future stages remain collapsed


• users can manually expand any stage when needed

This small UX improvement makes navigating long AI workflows significantly easier.

It reinforces the idea that good AI products are about more than model quality—they're also about thoughtful interaction design.

Challenges I Faced

Prompt Isolation

Early versions produced nearly identical responses.

The Product Manager sounded like the Architect.

The Backend Agent sounded like the QA Agent.

The solution wasn't a better model.

It was better prompt engineering.

Each agent was redesigned to produce unique artifacts with clear responsibilities.

State Management

Unlike a chatbot, DevTeam AI maintains project state across many stages.

The application tracks:

• approvals


• revisions


• dependencies


• generated artifacts


• conflicts


• baseline comparisons

Managing this workflow became one of the most interesting engineering problems in the project.

Designing Productive Disagreements

Perhaps the biggest lesson was this:

Adding more AI agents doesn't automatically improve quality.

Agents need meaningful reasons to interact.

That's why the CTO Reviewer and Negotiator exist.

Without review and disagreement, multi-agent systems quickly become multiple copies of the same assistant.

What the Platform Generates

From a single product idea, DevTeam AI can produce:

• Product Requirements Document


• Architecture documentation


• Mermaid diagrams


• API specifications


• Database schema


• Frontend implementation plan


• QA strategy


• CTO review report


• Negotiation decisions


• Revision summaries


• Starter project


• Code review


• Exportable ZIP package

Lessons Learned

This project changed how I think about AI systems.

The future isn't simply making one model smarter.

It's enabling multiple specialized agents to collaborate effectively while keeping humans firmly in control.

The most valuable ideas weren't:

• adding more prompts


• adding more agents

Instead, they were:

• clearer responsibilities


• approval workflows


• review cycles


• negotiation


• structured artifacts


• transparency

The quality of collaboration mattered far more than the number of agents.

What's Next

Although this was built for the hackathon, I see plenty of room for future improvements:

• Persistent long-term memory using vector databases


• Retrieval-Augmented Generation (RAG) for organizational knowledge


• Support for additional programming languages and frameworks


• CI/CD planning agents


• DevOps and infrastructure review agents


• Security and compliance agents


• Team collaboration with shared workspaces


• Deployment automation

Final Thoughts

Building DevTeam AI for the QwenCloud Global AI Hackathon was more than an opportunity to experiment with multi-agent AI—it was a chance to rethink how software teams can collaborate with intelligent systems.

QwenCloud provided the reasoning engine behind every specialized agent, while FastAPI, Next.js, and a workflow-driven architecture transformed those individual conversations into a coordinated software delivery process.

Rather than replacing software engineers, DevTeam AI demonstrates how AI can augment each stage of product development: from refining ideas and reviewing architectures to negotiating trade-offs and generating implementation scaffolds. The result isn't a single AI assistant—it is an AI engineering team that collaborates, critiques, revises, and works alongside humans.

As AI continues to evolve, I believe the next generation of developer tools won't revolve around isolated prompts. They will revolve around intelligent, specialized agents working together through structured workflows, with humans guiding the decisions that matter most.

DevTeam AI is my exploration of that future—and QwenCloud made it possible to bring that vision to life during this hackathon.

Project: DevTeam AI

Built for: QwenCloud Global AI Hackathon – Agent Society Track

Tech Stack: QwenCloud, FastAPI, Python, Next.js, TypeScript, Tailwind CSS, SQLite, Server-Sent Events