Gooo.

The thesis.

Gooo, short for Go Of Ontology, treats program construction as an inspectable language operation. Source files declare entities and activities with stable semantic identities. An assembling block adds the permitted typed changes, their intent, expected examples and a search budget. An agent can work with that explicit construction space rather than produce an unrestricted replacement body. A compatible local model can rank declared alternatives; the same route also works with deterministic ordering and no model.

The verification-camp connection is the compiler’s feedback and evidence interface. Gooo records what was selected, what was generated, what matched the supplied cases and what remains unobserved. These are scoped observations, not a proof that the examples exhaust the input domain or capture the author’s natural-language intent.

What it looks like.

activity Clamp(Integer) -> Integer
  computes "if input < 0 { return 0 } else if input < 10 { return input } else { return 10 }"
  assembling {
    choice "upper-comparison" operand_order at "1"
      intent "Check input below ten."
    case "-1" -> "0"
    case "5" -> "5"
    case "11" -> "10"
    attempts "8"
}

Distinctive moves.

• Source owns the search space. Alternatives and budgets live beside the activity, rather than only in an agent’s prompt. Model ranking cannot add a choice outside that declared route.
• Selection and execution have different records. Body generation retains source and case-scoring evidence. Package execution builds and runs the projection; saved replay reuses the selected program without new inference.
• Identity survives projection. Stable entity and activity identifiers link declarations, package interfaces and generated Go boundaries. Display names and semantic identity are separate concerns.
• Partial observations remain visible. Completeness reports retain failures, unattempted choices and unresolved execution obligations. A passing finite suite does not erase those other dimensions.

Maturity.

The repository ships an experimental Go compiler, project starters and runnable package examples. Its getting-started guide pins an installation route and explains execution and replay. The separate Go ports lab exercises generated programs against independent Go references and publishes browser examples.

Support is profile-specific: declaration checking, body generation and actual execution establish different claims. The examples document bounded syntax and input domains. Broader language coverage and independently sourced workflows remain development areas; construction receipts do not authenticate a caller or authorise external effects.

Agent tooling.

AGENTS.md defines source, generated-code and evidence ownership. The compiler exports JSON package interfaces and construction/context reports, while package execution and replay expose structured results for subsequent agent work. The workflow is described in the project’s source-assembly guide. The project and this submission use AI assistance; that attribution does not substitute for execution evidence.