QVRONE
Fig.0 · Software Factory

Requests in. Verified pull requests out.

Agents plan, build and prove the work. Your rules decide what may run, every stage is enforced by the harness rather than suggested, and the merge button stays with you.

Request accessThe factory line

The factory line. Six stages, each one enforced.

  1. 01Early access

    Intake

    A request arrives in plain words: from you in chat today; from GitHub issues, trackers, chat channels and schedules next.

    enforced › Every request enters the same governed path, in its workspace.

  2. 02Early access

    Spec

    The request becomes a content-hashed task spec: goal, scope, acceptance checks and a bar. The NeSy plan compiler checks the model's plan against it before anything runs.

    enforced › The bar is fixed before code. The model cannot widen its tools or turn an unknown into success.

  3. 03Early access

    Build

    The plan runs in an isolated sandbox. Every run keeps its spec, plan, diff, test output and artifacts.

    enforced › Read-only root, no network. Each tool call passes the gate.

  4. 04Coming

    Verify

    A separate verifier re-runs every check from a clean checkout and breaks each test once to prove it can fail.

    enforced › The builder never grades itself. A test that cannot go red does not count.

  5. 05Early access

    Deliver

    The change arrives as a pull request through the Qvrone GitHub App; CI results flow back into the review.

    enforced › Review decisions are recorded. There is no merge path: you merge.

  6. 06Coming

    Operate

    Scheduled route audits, dependency and secret scans become findings, then fix pull requests. Proven runs become recipes.

    enforced › Runs with no one starting it; secrets are never printed.

Inside the factory. What each stage looks like while it runs.

Fig.1 · sample

request › Fix: routes trust workspace_id from the body (#142)

task spec
goalWorkspace id comes from the session, never the request body
scopesrc/routes/** · no schema changes
acceptforeign workspace → 403 · own workspace → 200
barfixed before code · each check must fail when broken
compiled plan
  1. 1.read routes that take workspace_id from body
  2. 2.add session guard, remove body field
  3. 3.write 403 / 200 tests
  4. 4.sabotage: drop guard, expect RED

01 Spec before code

Early access

A request becomes a task spec with acceptance checks and a bar, fixed before a line of code is written.

  1. 1.1Scope names exactly which files and systems may change
  2. 1.2The plan is compiled from the spec
  3. 1.3Your rules check every step of the plan
Request access
Fig.2 · sample
#231 Session-bound workspace on routesvia GitHub App
  • ✓sandboxed runread-only root · no network
  • ✓typecheck0 errors
  • ✓tests0 failed · 0 skipped
  • ✓CI (GitHub checks)reconciled into review
  • ✓review decisionrecorded against this change
specplandifftest logartifacts
Merge ›ready for you · the agent cannot merge

02 Built in a sandbox, delivered for review

Early access

Plans run in an isolated sandbox, and the change arrives as a pull request with its evidence attached.

  1. 2.1Read-only root and no network in the sandbox
  2. 2.2CI results flow back into the review
  3. 2.3There is no merge path, only your button
Request access
Fig.3 · sample
build · sandboxed agent

$ task #142 · scope: src/routes

+ enforceSessionWorkspace(req)

- const ws = req.body.workspaceId

+ test: foreign workspace → 403

bar committed before code ✓

verify · independent agent

$ verify #142 · fresh checkout

typecheck ............ 0 errors

tests ................ 0 failed · 0 skipped

sabotage: drop guard → 403 test RED

restored → GREEN

VERDICT APPROVE → PR for you

03 Proven, not self-graded

Coming

A separate verifier re-runs every check from a clean checkout and breaks each test once to prove it can fail.

  1. 3.1The agent that builds is never the one that verifies
  2. 3.2A test that cannot go red does not count
  3. 3.3No verdict, no merge
Request access
Fig.4 · sample
open findings1
scan 1scan 14

02:00 scheduled run · no one started it

route audit 2 routes read workspace_id from body

osv scan 1 high · lodash 4.17.20

secret scan 1 token · .env.example:12 (value hidden)

fix PR #231 opened · waiting for your approval

04 Security lane

Coming

Scheduled route audits, dependency scans and secret scans become findings, then a fix pull request for you.

  1. 4.1Runs on a schedule, with no one starting it
  2. 4.2Secret values are never shown, only file, line and type
  3. 4.3Every finding and fix traceable in the ledger
Request access
Fig.5 · sample
approval requiredpolicy send_to_customer v2

Send 3 payment reminders on WhatsApp

tool  whatsapp.template.send
args  { invoices: [INV-1042, INV-1047, INV-1051] }
bind  sha256 7f3c…a91e  (tool · args · policy · run)
Approve ›Decline

… waiting for the owner. Nothing has been sent.

05 Approvals bound to one action

Early access

Risky steps wait for you. The approval covers the exact tool, arguments and policy you saw, once.

  1. 5.1A changed argument means a new approval
  2. 5.2A replay of a used approval is refused
  3. 5.3Everything else runs on its own and leaves a trace
Request access
Fig.6 · sample
runtoolruleverdict
run_8f25pull_request.openfactory_scopeconfirmed
run_8f24invoices.listread_onlyconfirmed
run_8f23whatsapp.sendservice_windowunknown
run_8f22bookings.cancelambiguous_targetrefused
run_8f21payment_link.createsend_to_customer → askconfirmed
run_8f20bookings.createbooking_hoursconfirmed
■ confirmed 4■ refused 1■ blocked 0■ unknown 1done-without-check 0

06 A ledger you can audit

Early access

Each run and tool call is recorded with the authority and policy decision that let it run.

  1. 6.1Confirmed, refused, blocked or unknown. Never a guessed done
  2. 6.2Tool-call audit kept as a signed hash chain
  3. 6.3Exportable when an auditor asks
Request access

Enforced, not advisory. An agent that grades itself, against a factory that proves the work.

QuestionAn agent that grades itselfQvrone Software Factory
Who checks the workThe agent that wrote the change runs its own tests and reports back.
A separate verifier re-runs the checks from a clean checkout.Coming
When it counts as doneWhen the agent says the tests passed.
When the result is read back from the real system and the verdict is recorded.Early access
Review and security findingsAdvisory comments; blocking a merge is left to your own CI settings.
The factory itself holds the merge until there is a verdict.Coming
ApprovalsApproving a tool or server once trusts it from then on.
Each approval is bound to one exact action (tool, arguments, policy) and works once.Early access
Audit trailLogs of what ran.
Each tool call recorded with the authority and policy decision that let it run, in a signed hash chain.Early access
PlansThe agent drafts a plan and starts editing once someone approves it.
The plan is compiled against a content-hashed spec: permitted tools, budgets, dependencies and a required verify contract.Prototype
Finishing a taskThe worker marks its own task complete.
A worker cannot mark its own milestone successful; the exit proof has to pass.Coming
TestsTrusted when green.
Each check is sabotaged once: it must go red, then green again.Coming

Capabilities. What exists today, and what is coming, labelled plainly.

Task specs and barsEarly access

Goal, scope, acceptance checks and a bar fixed before code.

Compiled plansEarly access

Plans compiled from the spec; every step checked by your rules.

NeSy plan compilerPrototype

Typed, budgeted plans limited to permitted tools; equivalent plans compile identically.

Agent computersPrototype

A shared, governed computer per workspace, with a leased screen per agent.

Paired computersEarly access

Your own machine, paired with a signed key, under the same gate.

Isolated sandboxEarly access

Read-only root and no network for code runs.

Evidence and artifactsEarly access

Spec, plan, diff, test output and artifacts kept per run.

GitHub deliveryEarly access

Pull requests through the Qvrone GitHub App; CI reconciled into review.

Review decisionsEarly access

Review decisions and comments recorded against the change.

Bound approvalsEarly access

One exact action, one use; a replay is refused.

Signed audit chainEarly access

Tool calls with authority and policy, tamper-evident.

Independent verificationComing

Clean-checkout re-run with sabotage-tested checks.

Security laneComing

Scheduled audits and scans, findings, fix pull requests.

Cheapest verifiable pathComing

Rules, recipes, cache and smaller models before the biggest one.