PrismOS

Hero
Dashboard
The Agents
The Agents Working
Benchmark

Inspiration

AI can generate code faster than ever, but there’s still a major problem: most tools struggle when working inside real existing products.

They often make incorrect stack assumptions, ignore existing architecture, recreate components that already exist, and miss integration risks. In real-world software delivery, writing code is only one piece of the puzzle. Product planning, architecture decisions, UX design, QA validation, and team alignment matter just as much.

That inspired PrismOS.

I wanted to build something beyond a coding assistant or chatbot. Instead of a single AI generating code in isolation, I asked: what if software delivery worked like a real product team with specialized AI agents collaborating, debating decisions, and resolving conflicts before shipping?

That idea became PrismOS: an AI operating system for autonomous feature delivery.

What it does

PrismOS transforms a feature request into a production-ready delivery package using a team of specialized AI agents.

A user provides product context through:

GitHub repositories
Uploaded files
Product screenshots
Live URLs
Product descriptions or schemas

PrismOS then activates 7 specialized agents:

Context Analyst → understands the existing product
PM → writes product requirements and user stories
Architect → designs system architecture
UI/UX Designer → creates UX and interaction specifications
Engineer → generates implementation-ready code
QA → validates tests, edge cases, and UX quality
Release Manager → resolves conflicts and makes final decisions

PrismOS also maintains Project Memory, which stores architecture decisions, shipped features, conflicts, and constraints across runs.

The final output includes:

Product requirements
Architecture decisions
UX specifications
Production-ready code
Test plans
Final ship/no-ship verdict

I also benchmark PrismOS against a naive single-model approach to clearly show the advantage of multi-agent collaboration.

How I built it

I built PrismOS as a full-stack AI orchestration platform.

Frontend

Next.js
TypeScript
Tailwind CSS

The frontend handles:

Project dashboard
Context upload flow
Live streaming agent panels
Benchmark comparison
Project memory visualization

One key product decision was streaming every agent’s output in real time so users can observe reasoning, conflicts, and decisions live.

Backend

FastAPI
LangGraph orchestration
Server-Sent Events (SSE)
PostgreSQL via Supabase

The backend manages:

Context ingestion
Agent orchestration
Conflict detection and resolution
Memory persistence
Streaming outputs
Benchmark generation

AI Layer

I built PrismOS around Qwen models.

Instead of relying on a single prompt, each agent has its own specialized system prompt, responsibilities, constraints, and output structure.

This creates much stronger specialization and more realistic collaboration.

Challenges I ran into

One major challenge was making the agents feel genuinely collaborative.

Many multi-agent systems are simply multiple prompts running independently without meaningful interaction. I wanted real collaboration with disagreements, tradeoffs, and resolution.

I solved this with:

Explicit conflict markers
Release Manager arbitration
Structured workflows
Shared project memory

Another challenge was context ingestion.

Users can provide context in many forms—repositories, screenshots, files, URLs, or text descriptions. Converting all of that into one reliable product context was difficult.

I addressed this by building a dedicated Context Analyst agent and ingestion pipeline.

Maintaining consistency across long multi-step workflows was also challenging. As more agents and outputs were introduced, preserving coherence became increasingly important.

One of the biggest challenges I also faced was deploying the application to Alibaba Cloud ECS. Setting up the server, configuring the runtime environment, handling networking and security settings, and ensuring the frontend and backend communicated correctly required significant troubleshooting. Working through these deployment issues gave me a much better understanding of cloud infrastructure and how to reliably deploy a full-stack application.

Accomplishments that I'm proud of

I'm proud that PrismOS feels meaningfully different from traditional AI coding tools.

Some accomplishments I'm especially proud of:

Building a true 7-agent collaborative system
Creating a dedicated Context Analyst for product understanding
Designing Project Memory for persistent learning across runs
Adding a specialized UI/UX Designer agent, not just engineering-focused agents
Building a clear benchmark system comparing PrismOS against single-model outputs
Creating a workflow that mirrors how real software teams operate

I'm especially proud of turning the idea of "AI agents working as a software team" into something tangible and interactive.

What I learned

Building PrismOS reinforced one major insight:

The future of AI software development is better coordination.

The most valuable AI systems will likely behave less like single assistants and more like specialized teams with memory, structured reasoning, and decision-making.

I also learned that context is critical.

Even powerful models struggle without context. But when context awareness, project memory, and specialized agents work together, output quality improves significantly.

What's next for PrismOS

This hackathon version proves the core concept, but I see much more ahead.

Next, I want to expand PrismOS with:

GitHub integration for private repositories
Better screenshot-to-context understanding with vision models
Semantic memory retrieval using embeddings
Team collaboration and shared workspaces
Deployment integrations with CI/CD pipelines
Direct pull request generation into existing repositories

My long-term vision is ambitious: I want PrismOS to become the operating system for software delivery, where teams can go from idea to production-ready implementation with AI agents handling the coordination overhead.

Deployment Note: The application was originally deployed on the hackathon-provided ECS infrastructure using the participant coupon to comply with the recommended deployment environment. After the promotional credits expired, the live demo was migrated to Vercel to ensure that judges could continue to access and evaluate the application without interruption.