Generation Overview

Generation starts from intent and constraints, then creates structured artifacts.

sigMAX separates the generation flow into two parts. The LLM helps shape intent into explicit contracts and controlled pseudo-code. Deterministic tools then turn those artifacts into C subset code, WASM modules, local stack files, containers and agreements.

The important rule is simple: creative assistance stops before executable authority begins. Each stage leaves evidence that can be parsed, validated and compared against the expected contract state.

Stage Responsibilities

Each stage owns a narrow responsibility. That separation is what keeps the generated result inspectable.

Stage	Main responsibility	Evidence
Intent	Capture what the application should do and which constraints matter.	Prompt context, project notes, architecture decisions.
Blueprint	Convert intent into a structured architectural plan.	Blueprint artifact and decomposition rationale.
Contracts	Declare the expected application, component and binary state.	Application, Component and Binary Contracts.
Controlled pseudo-code	Express executable intent without giving the LLM final code authority.	Pseudocode DSL files linked to Binary Contracts.
Deterministic generation	Produce C subset, WASM, routes, OpenAPI, Compose and container artifacts.	Generated files, hashes, compile reports.
Agreements	Record what was actually produced and accepted.	Application, Component, Binary and Storage Agreements.
Runtime	Execute validated WASM through declared primitives.	Health, logs, ObjectIR output, runtime checks.

Why The Split Matters

The generation pipeline deliberately separates creative shaping from executable production.

LLM output is useful for interpreting intent and drafting structured artifacts, but it is not trusted as final executable truth. Deterministic generators and validators take over before compilation, packaging and runtime execution.

This gives sigMAX three useful checkpoints:

expected state: what contracts say should exist;
produced state: what generators actually created;
observed state: what the runtime exposes when the artifact runs.

If those states diverge, the issue should become visible as drift instead of remaining hidden inside generated code.

Where To Continue

Topic	Next page
How pseudo-code is constrained	Pseudocode DSL
How C and WASM are produced	C/WASM Generation
How local stacks are generated	Compose Generation
What the LLM may and may not own	LLM Boundaries