PrismOS
Seven agents that are required to disagree before any code ships.
I defined the agent-society model, owned the blueprint through three versions, and made the architectural and scope calls. Implementation was directed rather than hand-typed — I reviewed output and gave corrective feedback. The scope enforcement was the part that mattered: every capability added after v1.0 went in as a patch against working architecture, never a rebuild.
How it holds together
Step 1 of 7
- Context Analystagent 0 · pre-LLM
- Product ManagerPRD · classify
- ArchitectpositionEngineerpositionQAposition · flags
- Release Managerbinding rulings
- UI/UX Designerfrontend only
- Engineerbuilds the ruling
- Verdictbinding verdict
Parses the GitHub repo, stack description and any URLs deterministically — no model call. Emits a structured ProductContextSummary injected at system-prompt level. Target: under five seconds.
The problem
AI coding assistants are single-voiced. One model takes a feature request and decides everything itself — scope, architecture, implementation, testing — and it never disagrees with itself. The output compiles and demos well, and it quietly skips every tradeoff a real team would argue about.
The second failure is context. Most agent tools generate in a vacuum. They do not know what the codebase already looks like, what stack it runs on, or what was decided three features ago. The result is technically valid and architecturally foreign.
Feature delivery is a coordination problem before it is a code-generation problem. The value in a team comes from friction — the architect pushing back, QA refusing to sign off, the PM cutting scope. Strip that out and call the result autonomous development, and you have a demo rather than a delivery system.
What I built
Point PrismOS at a codebase and describe a feature. It reads the existing product, loads project memory from prior runs, activates seven specialized agents, streams their reasoning live, forces them into structured debate, resolves conflicts through a Release Manager, and returns a package: production-ready code, tests, a conflict log, a benchmark, and a binding SHIPPABLE or NEEDS_REVISION verdict.
The full surface shipped — landing page, dashboard, two-step run creation, a live seven-agent streaming view, project and session history, a conflicts explorer, a benchmark comparison, an architecture page, and a self-contained demo mode.

The architecture
Context ingestion runs before any model call. GitHub parsing, file reading and URL crawling are deterministic and synchronous, targeted under five seconds, so no tokens are spent on I/O.
Context is injected at the system-prompt level rather than as a user message, so it does not inflate the turn count for every downstream agent.
Conflict is mandatory rather than emergent. Step three requires disagreement, and structured markers — SECURITY FLAG, INTEGRATION RISK — drive orchestration. A security flag from QA is non-negotiable and routes to the Release Manager. An unopposed integration risk logs as a warning without triggering resolution.
With zero context supplied, Agent 0 emits a minimal summary and the workflow proceeds normally, preserving the original feature-request-only path.
Decisions
Running seven agents was straightforward. Stopping them collapsing into polite consensus was not. Agents respond in parallel without seeing each other's output first, prompts require at least one surfaced disagreement, and the orchestrator routes on structured markers rather than on sentiment. Conflict had to be consequential or it was theatre.
Stack
- Orchestration
- LangGraph StateGraph · FastAPI · SSE streaming
- Model
- Qwen3-235B-A22B · DashScope
- Interface
- Next.js App Router · TypeScript · Tailwind v4 · Framer Motion · EventSource
- Data
- Supabase · PostgreSQL · Alibaba OSS
- Deploy
- Alibaba Cloud SAE
What it demonstrates
- Multi-agent orchestration with real conflict generation and resolution
- Codebase-aware generation that fits an existing system
- Project memory that compounds across runs
- Seven concurrent token streams rendered legibly
- A quality gate that will refuse to ship