Adaptive software building

One goal. A living plan. Small blocks that keep moving.

Solana keeps the real outcome fixed while its strategy adapts. Sol plans, Luna implements, independent evidence decides, and one authority safely integrates the result.

Goal contract Preserve intent
Execution strategy Adapt from evidence
1 workspace authority

Only retirement mutates the repository.

3 Luna implementation lanes

Disjoint blocks overlap when resources allow.

5 durable pipeline stages

Every stage resumes independently.

20–40k accepted lines per 12 hours

Capacity metric only—never a quota or reason to discard work.

Architecture explorer

The same system scales from one fix to a huge product.

Pick a goal size. The graph changes, but every runnable leaf keeps the same safety contract.

Small fix

One block, no ceremony

Solana work graph Interactive graph showing how a goal becomes verified work blocks.
01
One honest goal

Must-have outcomes remain traceable to proof.

02
One reusable block

Frontend and backend are facts, not separate runtimes.

03
One retirement authority

Many agents can work; only one boundary integrates.

Adaptive goals

Change the strategy, not the truth.

Failed evidence rewrites only the affected future. Valid accepted work keeps moving.

Solana adaptive goal loop Evidence flows through observe, diagnose, revise, expand, and continue around a stable goal contract. Goal contract Must-have intent stays fixed Observe Diagnose Revise Expand Continue
  1. 01
    Repair precisely

    Use the rejected candidate and exact evidence when it remains safe.

  2. 02
    Split the block

    Reduce one oversized or confused outcome into fitted leaves.

  3. 03
    Reroute capabilities

    Add diagnosis, contract, visual, security, or performance proof only when needed.

  4. 04
    Replace the strategy

    Change a library, algorithm, architecture boundary, or implementation approach.

  5. 05
    Revise optional scope honestly

    Only the product contract can justify a tradeoff. Throughput metrics never can.

ReuseCompatible accepted artifacts

No reimplementation and no repeated proof.

ReverifyValid work in a changed environment

Rerun evidence without asking Luna to rebuild.

SalvageUseful sealed candidates

Repair from the candidate when its lineage is safe.

SupersedeOnly incompatible descendants

Independent siblings continue through the pipeline.

Pipeline execution

Five stages, occupied at the same time.

Planning can prepare tomorrow's blocks while Luna builds one, verification judges another, and retirement promotes a third.

1Fetch

Select the highest-value compatible block.

Quick settings fixforeground
2Decode

Pin context, contracts, claims, and proof.

Session recoverycontext ready
3Execute

Luna writes inside an isolated worktree.

Tab lifecycleLuna lane 2
4Verify

Run focused evidence against the candidate.

Navigation shellbrowser proof
5Retire

Integrate once and update requirement truth.

URL loaderqueue position 1

Initial local envelope

Fast where independence is real.

Three is a ceiling. Solana lowers concurrency when work conflicts, evidence backs up, or the computer is under pressure.

Interrupt Foreground Background Maintenance
LLuna lane 1

Implementation

LLuna lane 2

Implementation

LLuna lane 3

Reserved when useful

BBrowser lane

One exclusive session

RRetirement lane

One repository authority

Composable capabilities

No mandatory frontend-to-backend conveyor belt.

A block takes only the path its evidence and risk require.

InspectRepository context

Symbols, nearby contracts, tests, and current behavior.

ResearchExternal evidence

Used only when the repository cannot resolve an ambiguity.

SpecifyInterface or visual contract

High-fan-out decisions become accepted artifacts first.

ImplementBounded Luna change

One outcome and one primary write domain.

VerifyCommands and product flows

Focused leaf checks, broader milestone evidence.

ReviewFresh semantic judgment

Added at architecture, security, visual, and release boundaries.

PackageFrozen artifacts

Deterministic outputs tied to exact accepted source.

DeployAuthorized targets

Exclusive lease, smoke proof, and rollback evidence.

Multiple Solanas

Many systems can work. Authority stays singular.

Scale execution outward without allowing two controllers to mutate the same repository.

Solana federation map One program authority coordinates workspace authorities, which each coordinate local and remote block executors. Program authority Goal, requirements, contracts, release Workspace authority A One retirement queue Workspace authority B One retirement queue Workspace authority C One retirement queue ExecutorsLocal or remote ExecutorsImmutable results ExecutorsNo Git authority
Invariant Many systems may think and execute; one named authority retires each resource.

Capacity, measured honestly

20–40k is an instrument panel—not the destination.

The benchmark tells us whether planning, execution, testing, and retirement are flowing. Missing it starts a bottleneck investigation. It never changes product scope or the meaning of complete.

3Luna lanes × 2–3blocks / hour × 250–400accepted lines
18–43kmodeled range over 12 hours

Generated, copied, vendored, duplicated, and formatting-only lines are excluded.

Build order

Prove the idea before trusting it.

Each phase earns the next one with running evidence.

A
Planning kernel

Goal contract, ledger, recursive expansion, fit gate.

First
B
Path and scheduler simulation

Capability routes, hazards, priority, machine pressure.

Planned
C
Durable stage engine

Crash every boundary and prove exact resume.

Planned
D
One live Sol + Luna block

Small real canary, one accepted retirement.

Planned
E
Adaptive parallel pipeline

Three lanes, rejection split, and quick-fix priority.

Planned
F
Cross-capability product

UI, API, responsive proof, and combined integration.

Planned
G
Endurance benchmark

Twelve hours, failures, restarts, and honest throughput.

Planned
H
Satellite federation

Remote immutable execution and multi-workspace contracts.

Later

The shortest version

Keep the goal honest. Keep the blocks small. Let evidence change the route.

Run through another scenario