Discovery

How Adapt-1 can form task-facing structure from experience instead of requiring an authored ontology.

Discovery changes where task-specific structure comes from in Adapt-1.

Adapt-1 can form task-specific state from admitted evidence without a task-specific training dataset. Earlier Domain configurations could still define part of the learner-facing ontology before the first event arrived. Discovery makes that authored ontology optional. A Domain can keep the public task boundary while Adapt-1 forms useful task-facing structure during a zero-start run or a separate acquisition phase.

public Domain boundary + authored learner-facing structure

can become

public Domain boundary + admitted evidence
      ↓
Discovery forms learner-facing structure

The Domain remains. The requirement to author its ontology does not.

What changes

A Domain still gives one instance a stable public scope. It can define event meanings, observable outcomes, permitted actions, lifecycle boundaries, and the structured result the application expects.

Discovery lets more of the structure inside that boundary form from admitted evidence.

Public boundary remains	Can form from admitted evidence
Event and outcome meanings	Useful learner input paths
Target or result type	Predictive combinations of observable fields
Episode and reset boundaries	Bounded temporal relationships
Available actions and reward semantics when applicable	State-dependent action values and delayed-credit structure
Observable before/after event boundary	Transition and causal bindings where supported
Safety and execution constraints	Predictive rules and other task-local structure

This does not move the environment into Core. The world still produces observations and consequences. The application still exposes the public interaction boundary. Discovery changes how much learner-facing structure must be written before Adapt-1 can begin forming useful state.

Discovery spans several learning paths

Discovery is a structure-source option across learning paths that can form task-facing structure from evidence.

Discovery path	What forms from evidence
Transition Discovery	Executable input projections and compatible before/after causal bindings
Structure Discovery	Outcome-useful fields, combinations, bounded temporal lags, and predictive rules
Sequential Discovery	State-dependent action values and delayed credit across ordered interaction

A Domain can use one path or combine compatible paths. Each path keeps its own target, evidence, attribution, and abstention contract while contributing to the same Domain state under the declared learning lifecycle.

A Domain can therefore use discovered, authored, or mixed task-facing structure. Authored configuration remains available when a public surface must be fixed before use.

Discovery does not choose the learning schedule

Fix the complete learning-run boundary before classifying the state. Discovery can operate under several schedules.

Schedule	Discovery behavior
Zero-start learning across a run	The complete run begins with empty task-specific learned state. Discovery forms structure from events inside the run and can retain it across compatible episodes or passes.
Zero-start task-local learning	Each independently redrawn task begins empty, forms structure from local evidence, produces its result, and then resets.
Separate acquisition, then frozen use	Discovery forms structure from acquisition records outside the new run. The acquired state is then used without learner writes.
Separate acquisition, then continued adaptation	Discovery forms the starting state outside the new run, then current outcomes continue revising it.

empty task-specific state
-> admitted evidence
-> Discovery forms usable structure
-> later work can use that structure

The sequence above can happen before a declared run or inside it. State retained from episode 1 into episode 2 is still state earned inside a zero-start run when the complete run began empty. It is not separately acquired state merely because a later episode can use it.

Three ways to use a Domain

Mode	When to use it
Discovery	The public task boundary is clear, but useful task-facing structure should form from experience
Authored ontology	Task-facing structure must be explicit, reviewed, or fixed before use
Mixed	A small reviewed surface should remain fixed while other supported structure is discovered

Authored ontology is therefore still available. Discovery removes its status as a prerequisite.

A practical workflow can begin with Discovery, inspect what became usable, evaluate it on held-out work, and later pin reviewed parts of the ontology when a stable production contract is useful.

Inspectability remains part of the contract

Discovery does not turn the Domain into an opaque setup step. Public API responses can expose whether Discovery is still accumulating or ready, which input paths became active, the current learned structure, supporting evidence, contradicting evidence where applicable, learner versions, and abstention states.

The exact diagnostics depend on the configured learning relationship. The important property is that discovered structure can be inspected and evaluated before an application relies on it.

What Discovery does not remove

Discovery does not remove the need for a valid task boundary. An application still has to expose the information that exists in the real workflow.

It cannot learn from an outcome that is never returned. It cannot use an action the application does not permit. It should not receive a hidden answer, private evaluator state, or post-outcome value as if that information were available before the result.

These are interface and evaluation boundaries, not authored task knowledge.

Why it matters

The architectural progression is simple:

Adapt-1 Preview
task-specific state can form from evidence
+
some learner-facing ontology can be supplied explicitly

Discovery
the same acquisition and update schedules remain available
+
authored learner-facing ontology becomes optional
+
task-facing structure can form from admitted evidence

This reduces the amount of task-specific engineering required before an unfamiliar structured environment can become learnable, while preserving an explicit public boundary and inspectable state.

Choose a learning setup

Distinguish zero-start learning from state formed in a separate acquisition phase.

Use Discovery

Configure Discovery, send events, inspect readiness, and query discovered structure.

Sequential Discovery

Form state-dependent action values and delayed credit from ordered interaction.

Author a Domain ontology

Use explicit reviewed task-facing structure when the application requires it.

Choose how a Domain learns

Choose the learning relationship from the observable task loop.

Adapt-1 foundations

See how Discovery fits the wider adaptive substrate.