The open-source Convergence App Builder.
Generate a working app from intent, then verify every agent turn against its business requirements.
Quickstart · Why convergence · The harness · Contribute
The model generates. The harness verifies. Humans decide when it is ready.
QuantumByte is early, working, and intentionally being built in public. We are looking for founding contributors who believe software should be shaped by the people who understand the problem, not only by the people who can code.
Join the founding group on Discord
Vibe coding made software creation accessible. That is the breakthrough.
But an app can look finished long before it is ready for real operations. The interface renders. The happy path works. The demo impresses. Important requirements can still be missing, misunderstood, or silently broken.
We call this false convergence.
Generation gets you to an app that builds. Convergence asks what comes next:
- Does the app still match the original intent?
- Are its critical business requirements satisfied?
- What evidence supports each verdict?
- What must be repaired before humans trust it?
QuantumByte turns app generation into a continuing loop:
Intent -> Build -> Verify -> Evidence -> Repair or Ready
The current open-source release begins with explicit business requirements. After every agent turn, a separate read-only harness checks the app requirement by requirement and returns structured verdicts with evidence.
- Conversational intent capture and product overview
- Agent-generated applications in dedicated project repositories
- Build recovery after every completed agent turn
- Live app previews with health checks and device frames
- Worker coordination with project affinity and turn recovery
- Requirements derived from the product overview
- User-locked requirements that remain authoritative
- Independent, read-only audits for every requirement
- Structured
SUCCESSorFAILverdicts with evidence INCONCLUSIVErecorded separately from genuine failure- Diff-scoped re-verification when relevant files change
- Non-blocking background runs with live verdicts in the UI
- Docker and Docker Compose (Postgres, Redis, and minio run in containers)
- Node.js 20+ and npm
- Python 3.11+
- An Anthropic API key for the current worker implementation
git clone https://github.com/QuantumByteOSS/quantumbyte.git
cd quantumbyte
make install
make db-up
make migrate
make devOpen http://localhost:3000. Run make help to see all development commands.
For environment variables, service topology, and troubleshooting, read docs/running.md.
User intent
|
v
Product overview -> Builder agent -> Working app
|
v
Read-only harness
|
+------------------+------------------+
| | |
Verdict Evidence Watched files
| | |
+------------------+------------------+
|
v
Repair or ready
The builder and verifier are deliberately separated. The builder can edit the project. The harness evaluates one business requirement at a time without inheriting the builder's conversation, and it cannot modify the repository it is auditing.
apps/web: workspace, chat, live preview, and requirements UI using Next.js, TypeScript, and Prismaapps/orchestrator: project assignment, worker coordination, and recovery using Python and PostgreSQLapps/worker: agent execution, build loop, workspace management, and requirements harness using Python and the Claude Agent SDK- PostgreSQL: source of truth for projects, messages, workers, requirements, and verdicts
- Redis: per-project harness locking
- minio: S3-compatible store for agent-generated assets
The current worker uses the Claude Agent SDK. Provider-neutral agent boundaries and additional model providers are on the roadmap.
See ARCHITECTURE.md for the system overview.
QuantumByte is an early executable system inspired by Convergence Programming, a research framework for AI-assisted programming and agents.
Traditional software generation is often framed as specification -> program. Convergence Programming studies the larger trajectory:
lossy intent
-> generated behavior
-> observation
-> evidence
-> repair
-> readiness decision
-> action or block
The current harness implements one part of that agenda: continuous verification of generated software against explicit business requirements. It does not yet claim full world-grounded verification, complete production readiness, or the proposed ConvergenceBench evaluation framework.
- Intent-to-app generation
- Live previews and health checks
- Continuous business-requirements harness
- Per-requirement verdicts and evidence
- One-command self-hosting
- Model and agent provider adapters
- Concept, code, and blueprint editors
- World-grounded evidence and readiness gates
- ConvergenceBench reference tasks and evaluation tooling
See docs/roadmap.md for milestone details.
The AI app-generation layer is commoditizing. We would rather help it happen than pretend otherwise.
Generating more code is not the durable problem. The harder problem is keeping human intent, AI interpretation, generated behavior, and operational requirements aligned as the system changes.
We are opening the engine so programmers and researchers can inspect the harness, challenge its assumptions, reproduce its behavior, and help build better ways to decide when AI-generated software is actually ready.
The first contributor group is intentionally small. We are looking for engineers with taste, first-principles thinkers who still ship, and researchers interested in requirements, verification, agents, and human-AI collaboration.
- Join the Discord and introduce yourself.
- Read CONTRIBUTING.md.
- Review docs/roadmap.md and propose where you can help.
All participation is governed by our Code of Conduct. Report security issues according to SECURITY.md.
QuantumByte is licensed under the Apache License 2.0.