LAB / 001 · AUDITED ARTIFACT

RogueBall: from claim to evidence in Godot

The original snapshot of this football roguelike did not start: it lacked the .NET project required by Godot C#. In an isolated copy, a one-file repair enabled a clean build, a 120-frame run and a test of the initial playable state.

00 / IN TWO MINUTES

What the artifact proves today

The original snapshot fails to create its autoload because .csproj and .sln are absent.
Adding only the .NET project lets App.cs compile with zero errors and warnings.
Godot loads the autoload and scene and completes 120 headless frames without runtime errors.
A functional probe verifies initial state and that passing consumes one action.
Without creation logs, full autonomy cannot yet be attributed to an agent team.

ARCHITECTURE · RESPONSIBILITY AND PROOF

The system is not done when an agent says “finished”.

Each role produces an artifact or a check. The coordinator may close, iterate or escalate only from observable evidence.

Bounded multi-agent loop

01 · HUMAN

Sets the brief, boundaries and actions requiring approval.

02 · COORDINATOR

Divides work, keeps state and applies the iteration budget.

03 · SPECIALISTS

Design and engineering produce changes with minimum tools.

04 · VERIFIER

Runs import, build, runtime and probes without rewriting the criterion.

PASS

The agreed checks produce sufficient evidence.

ITERATE

The failure is classifiable and correction budget remains.

ESCALATE

The criterion is subjective, risky or no longer demonstrable.

Four questions that must not be conflated

PROVENANCEPENDING

Who created each part and with what intervention? Complete creation logs are absent.

ARTIFACTVERIFIED

Hashes identify the exact snapshot that was inspected.

EXECUTIONVERIFIED AFTER REPAIR

A copy with one added .csproj builds, runs 120 frames and passes one bounded probe.

PRODUCT QUALITYPENDING

There is insufficient proof of a complete match, fun, balance, performance or compatibility.

RUNTIME AUDIT · 15 AUG 2026

RogueBall_CodeOnly_Godot

LEVEL 3 / REPAIRED RUNTIME

The audit preserves two results: the original snapshot fails, while a repaired temporary copy builds and runs. The repair adds only the .csproj that Godot documentation requires C# projects to retain. The original project was not modified.

REAL CAPTURE · 60 FRAMES AT 30 FPS · 960×800 VIEWPORT · REPAIRED COPY

ENGINE: Godot 4.7.1 stable .NET
BUILD: 0 errors · 0 warnings
SMOKE RUN: 120 frames · clean output
FUNCTIONAL PROBE: Initial state + pass
REPAIR: 1 .csproj file
ORIGINAL SNAPSHOT: Not runnable as stored

Verified at runtime

✓The official engine archive matches the SHA-256 published by the Godot repository.
✓The original snapshot emits an autoload error even though the process exits with code zero.
✓With the minimal .csproj, dotnet build produces RogueBall_CodeOnly.dll with no warnings or errors.
✓Godot initializes .NET, loads App.cs and Empty.tscn and exits cleanly after 120 frames.
✓The probe finds half 1, ten actions, pass enabled and shot blocked; after passing, the HUD reports nine actions.

Still unproven

○The original snapshot running without the missing file.
○A complete match and every state transition.
○Sustained performance or a 60 FPS target.
○Fun, balance or device compatibility.
○Prompts, history, commits and interventions proving agent provenance.

INSPECTED EXCERPT · APP.CS

Snapshot SHA-256 ↓Runtime audit ↓Reproduction protocol ↓.NET repair ↓Functional probe ↓

private void OnShoot()
{
    if (possession != Side.Player || actions <= 0 || zone != 3) return;
    ConsumeActions(3);
    float baseChance = 0.45f;
    if (rng.Randf() < baseChance)
    {
        goalsPlayer += 1;
        Kickoff(playerScored: true);
    }
    else
    {
        possession = Side.Enemy;
        zone = 2;
    }
    UpdateUI();
}

Hypothesis and scope

Hypothesis: with filesystem, terminal and headless Godot tools, an agent team can produce a small prototype and fix technical failures without continuous human intervention. Scope must be narrow enough to test the system rather than game ambition.

✓One core mechanic.
✓One playable scene and one result screen.
✓Defined keyboard and controller inputs.
✓No external services or purchases.
✓A maximum iteration and cost budget.

Team architecture

Each role has different context and authority. The coordinator does not edit everything; the verifier does not silently rewrite the work it assesses.

Coordinator

Sets scope, divides work, preserves criteria and chooses iteration or escalation.

Game designer

Defines loop, rules, states, difficulty and player feedback.

Godot engineer

Creates scenes, resources, GDScript and project settings.

QA / verifier

Runs imports, analysis, tests and bounded sessions; returns evidence.

Tools

Filesystem, version control, Godot commands and log capture.

Human

Approves brief, risky actions and final acceptance of subjective criteria.

Autonomous loop

The coordinator maintains explicit state and prevents endless iteration.

✓Create or update one bounded artifact.
✓Run headless import and collect errors.
✓Check scripts and launch the scene for a bounded number of frames.
✓Classify syntax, resource, behavior or unverifiable-criterion failures.
✓Assign the fix to the right specialist.
✓Repeat until passing or exhausting budget, then escalate.

Tests and evidence

Godot supports command-line scripts, import, execution and export. Verification can therefore rely on engine output and artifacts rather than trust in model prose.

Integrity

project.godot exists, paths resolve and import completes.

Analysis

Scripts parse with no blocking errors.

Execution

The scene starts, maintains the intended loop and exits cleanly.

Behavior

Instrumented tests observe deterministic states and rules.

Export

A preset creates a reproducible build when templates are installed.

Record

Each iteration stores objective, change, command, output and decision.

Claims that remain off-limits

The audit does prove a build, a headless run and one bounded behavior in the repaired copy. It does not prove that the original snapshot runs or who created it: without prompts, agent history, commits and human interventions, there is no certified end-to-end autonomous provenance.

✓Do not transfer repaired-copy results to the original snapshot.
✓Do not claim full autonomy without prompts, history and interventions.
✓Do not confuse one verified action with a complete match.
✓Do not confuse implemented rules with tested fun, balance or performance.
✓Do not publish time or cost without reproducible measurement.

REF

Official technical basis

ECOSYSTEM / NEXT

Inspect how it was built and take the game into a test with players.

01 / NEXT ROUTE

Laboratory

Inspect systems, artifacts and limits through verifiable demonstrations.

Explore this route↗

02 / NEXT ROUTE

Beta Lab

Get structured, reproducible feedback from real people.

Explore this route↗

NEXT STEP

Want to apply this pattern to your product?

The same build, run and verification loop can be adapted to internal apps, agents and AI products.

Tell me your case↗More resources→