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
Top comments (0)