Our approachResearch

Software does not have to jump directly from language to arbitrary code.

Intent-space explores a different path: let a generative system propose an inspectable application model, let deterministic boundaries decide what is valid and supported, and let a capability-bounded runtime retain execution authority.

01 / THE MISMATCH

Open language meets finite execution

Human purpose can be open-ended. Execution authority does not have to be.

Natural language is useful precisely because people do not need to speak in implementation primitives. But a runtime still benefits from explicit knowledge of what can exist, what can mutate state, which references must resolve and which capabilities are actually implemented.

Common generative pattern

Intent→Model→Arbitrary code→Runtime

Generation and executable implementation can collapse into the same artifact.

Intent-space research direction

Intent→Proposal→Inspectable structure→Boundary→Runtime

The model proposes structure. Deterministic mechanisms decide what may continue.

02 / SEPARATIONS

Five distinctions worth preserving

Trust becomes easier to reason about when different questions get different answers.

01Purposeis notimplementation

02Proposalis notauthority

03Validis notruntime-supported

04Supportedis notsuccessfully generated

05Existence proofis notproduct maturity

These separations are not claims that every useful application can already be represented. They are the accounting system the project uses to avoid turning one kind of success into a broader claim by implication.

03 / THE BET

Bound the authority, not the purpose

The long-term bet is not that software becomes smaller. It is that the space of purposes can stay open while execution remains legible.

A closed capability vocabulary necessarily creates limits. Intent-space treats those limits as visible engineering boundaries rather than asking a producer to escape them by inserting arbitrary implementation code. A useful future system could grow through reviewed capabilities, richer application primitives and broader runtime support while preserving the distinction between proposal and authority.

What is still a thesis

The project has not established universal application coverage, production readiness, autonomous deployment or the future ecosystem described here. Those remain separate questions from the current execution proof.

04 / IF IT WORKS

What could change

Generation could become less about emitting code and more about compiling intent into explicit capabilities.

Debugging

Inspect the middle

Failures can be discussed as representation, validation, support or generation failures instead of one opaque “AI failed” category.

Security

Authority lives outside the producer

A generated declaration can request behavior without becoming the mechanism that grants itself arbitrary execution power.

Ecosystem

Extend capabilities deliberately

Future renderers, adapters and capability packages could broaden what the runtime supports without turning every extension into a producer-written escape hatch.

05 / EVALUATE IT

Do not accept the thesis because the website is persuasive

Follow the claim down to its boundary.

The right way to evaluate Intent-space is to ask what is representable, what is contract-valid, what the runtime supports, what the model can generate and which results have actually been tested.

See development progress →See the product Architecture tour