quantumbyte

本页保存的是公开项目资料快照，阅读过程不需要连接 GitHub。

Vibe coding is just the beginning.

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

Why convergence

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.

What ships today

App builder

• 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 harness

• Requirements derived from the product overview
• User-locked requirements that remain authoritative
• Independent, read-only audits for every requirement
• Structured SUCCESS or FAIL verdicts with evidence
• INCONCLUSIVE recorded separately from genuine failure
• Diff-scoped re-verification when relevant files change
• Non-blocking background runs with live verdicts in the UI

Quickstart

Prerequisites

• 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

Run locally

git clone https://github.com/QuantumByteOSS/quantumbyte.git
cd quantumbyte

make install
make db-up
make migrate
make dev

Open http://localhost:3000. Run make help to see all development commands.

For environment variables, service topology, and troubleshooting, read docs/running.md.

How the harness works

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.

Architecture

• apps/web: workspace, chat, live preview, and requirements UI using Next.js, TypeScript, and Prisma
• apps/orchestrator: project assignment, worker coordination, and recovery using Python and PostgreSQL
• apps/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.

Convergence Programming

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.

Roadmap

• 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.

Why open source

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.

Contributing

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.

1. Join the Discord and introduce yourself.
2. Read CONTRIBUTING.md.
3. 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.

License

QuantumByte is licensed under the Apache License 2.0.