Use Discovery

Discovery forms learner inputs and task structure from evidence admitted by a Domain. The Domain defines the public scope and event boundary. Use Discovery for a new structured task when the target or measured outcome and the public boundary are clear, while useful inputs, representations, causal bindings, or action values should form from admitted evidence. Keep an authored ontology when reviewed task-facing structure must remain explicit. A mixed setup is supported when only part of the surface should stay authored.

Choose the starting state and update policy separately from the Discovery configuration. See Learning schedules.

The available Discovery paths form the following structures:

Discovery path	Learns	Primary output
Transition Discovery	Stable scalar input paths and optional before/after causal bindings	`transition_prediction` and `learning_state.subsystems.structured_transition`
Structure Discovery	Outcome-useful fields, combinations, bounded temporal lags, and predictive rules	`induced_structure` and `learning_state.subsystems.autonomous_structure`
Sequential Discovery	State-dependent action values and delayed credit across ordered interaction	Selected policies and episode-aware `feedback_policy` state

Discovery operates on typed structured events and retained learner state without an LLM. The application declares the target and the meaning of its events.

Discovery lifecycle

Discovery is evidence-driven and can begin before an executable projection, active representation, or usable sequential policy exists. Mechanisms explains how Core forms and uses a learner view.

Domain created
eligible events or feedback arrive
projection, representation, or sequential evidence accumulates
usable task-facing structure forms
eligible earlier evidence contributes under that structure
later predictions, hypotheses, or selections can change

See adaptation in the loop

Transition Discovery can learn reward predictions from a stream of measurements, choices, and observed outcomes. The application compares predictions for its permitted choices, executes one, and returns its measured reward to the same Domain. Later predictions can use the new evidence. See Learn choices from measured outcomes for the complete loop. Sequential Discovery can revise an action value after receiving its observed consequence:

state A
-> select action X
-> execute action X
-> return the observed next state and reward

state A or a compatible later state
-> retained Discovery state contributes
-> selection can change to action Y

Transition and Structure Discovery update their projections or rules from eligible events. Inspect path-specific readiness and evidence alongside learner versions and selection attribution.

Application declarations

Every Discovery Domain needs a small semantic boundary:

A stable domain_id and public event or feedback meaning.
An observable target, measured outcome, or reward for the applicable Discovery path.
The type, meaning, and valid range of each declared target or outcome.
A boundary that separates information available before a result from what becomes observable afterward.
Episode and reset identifiers when temporal or Sequential Discovery is used.
Candidate actions, legal constraints, and safety rules when the application can act.

The Domain can leave supported learner inputs, representations, bindings, and action values for Discovery to form from admitted evidence.

Choose Discovery or authored ontology

Goal	Configuration
Predict an observable target from stable fields in the same event	`learning.transition.autonomous_projection.enabled: true` with empty `input_paths`
Discover a categorical or numeric rule over many candidate fields	`learning.structure.enabled: true` with empty `feature_paths`
Discover useful feature combinations or temporal lags	Enable `learning.structure.representation`
Discover state-dependent action values from delayed outcomes	Enable `learning.sequential` and supply real episode, step, next-state, reward, and terminal fields
Discover predictor inputs and before/after causal bindings together	Leave `input_paths`, causal `intervention_path`, and causal `variables` unresolved; enable `autonomous_projection`, `discover_causal_bindings`, and `causal_graph`
Discover before/after causal bindings while controlling learner inputs	Declare `input_paths`, enable transition projection, and enable `causal_graph`
Preserve an authored or reviewed ontology	Declare `input_paths` or `feature_paths`; explicit paths remain authoritative

Exclude target-derived fields from pre-outcome inputs. Review discovered paths before using a Domain for production decisions or an evaluation.

For an unfamiliar process, the autonomous causal example starts with unresolved predictor inputs and causal bindings. The unknown action-effects workflow shows what the application supplies and what Adapt-1 learns through execution.

Minimal transition Domain

Leave input_paths empty and declare the target. Adapt-1 can then discover a stable input projection from eligible structured fields in the events you send. The numeric settings below are example parameters.

{
  "domain_id": "process-output-demo",
  "session_id": "ignored",
  "description": "Predict an observed process output from available measurements.",
  "schema": {
    "event_types": ["observation"]
  },
  "learning": {
    "enabled": true,
    "transition": {
      "enabled": true,
      "event_types": ["observation"],
      "targets": [
        {
          "path": "values.process.output",
          "type": "number"
        }
      ],
      "required_support": 3,
      "numeric_model": "auto",
      "autonomous_projection": {
        "enabled": true,
        "minimum_observations": 3,
        "minimum_availability": 0.8,
        "maximum_input_paths": 8
      }
    }
  }
}

Create it with the production API:

curl -sS -X POST \
  "https://rei-neuroadapt-api.reilabs.org/api/v1/domains" \
  -H "Authorization: Bearer $ADAPT1_API_KEY" \
  -H "Content-Type: application/json" \
  --data @examples/domains/transition-numeric.domain.json

The hosted API derives tenant and session ownership from the bearer token. The session_id field remains present for request compatibility and can be set to ignored.

Inspect transition readiness

For transition projection, inspect every event response:

{
  "learner_eligibility": {
    "accepted": false,
    "rejection_reason": "projection_accumulating",
    "sample_count": 0,
    "autonomous_projection": {
      "status": "accumulating",
      "buffered_events": 2,
      "input_paths": []
    }
  }
}

When discovery becomes ready, the buffered events are reconsidered under the discovered path set:

{
  "learner_eligibility": {
    "accepted": true,
    "sample_count": 3,
    "sample_count_delta": 3,
    "autonomous_projection": {
      "status": "ready",
      "schema_changed": true,
      "revision": 1,
      "input_source": "discovered",
      "input_paths": [
        "values.process.pressure",
        "values.process.temperature"
      ]
    }
  }
}

sample_count_delta can be greater than one on the discovery event because previously buffered events are rebuilt into eligible samples.

Query with current context

Once the projection is ready, pass the current observable fields through context. Do not include the withheld target.

{
  "session_id": "ignored",
  "question": "Predict the process output.",
  "context": {
    "values": {
      "process": {
        "temperature": 30,
        "pressure": 1.2
      }
    }
  },
  "return_fields": [
    "transition_prediction",
    "learning_state"
  ],
  "update_memory_state": false,
  "allow_exploration": false
}

Read the prediction only when transition_prediction.status is predicted. Preserve the abstention reason, support, evidence IDs, model version, and discovered path set with the result.

Extend the configuration

Enable discovery on an existing Domain

Learning configuration can be updated through the Domain rules route:

curl -sS -X POST \
  "https://rei-neuroadapt-api.reilabs.org/api/v1/domains/YOUR_DOMAIN_ID/rules" \
  -H "Authorization: Bearer $ADAPT1_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "session_id": "ignored",
    "learning": {
      "enabled": true,
      "transition": {
        "enabled": true,
        "event_types": ["observation"],
        "targets": [
          {
            "path": "values.process.output",
            "type": "number"
          }
        ],
        "autonomous_projection": {
          "enabled": true
        }
      }
    }
  }'

Send a complete learning declaration; the supplied section replaces its previous value. Preserve the enabled learners and feature paths that should remain in use. For a controlled migration, create a new Domain, replay only approved training events, inspect the discovered state, and move application traffic after validation.

Explicit, automatic, and mixed contracts

Mode	Input declaration	Behavior
Automatic	Empty `input_paths` or `feature_paths`	Core discovers eligible structure from events
Explicit	Non-empty paths	Declared paths remain authoritative
Mixed	Explicit transition inputs plus autonomous causal binding, or explicit base fields plus representation discovery	Core discovers only the undeclared portion

This lets an application explore with automatic discovery, review the resulting structure, and then pin approved paths without changing routes or event shapes.

Production checklist

Declare the complete learning-run boundary and starting state before collecting results. Use empty state for a zero-start run and fresh acquisition state when building a separate checkpoint.
Preserve a holdout period, entity split, or episode split that did not form the discovered state.
Check path-specific admission and sample-count changes, including buffering and duplicate handling.
Inspect discovered paths, active representations, sequential model state, evidence IDs, learner versions, and selection attribution where applicable.
Verify the learner view contains no target-derived value, correct action, private evaluator output, or post-outcome leakage.
For frozen evaluation, freeze configuration and learner updates. For online evaluation, declare the allowed updates and record each result before returning its outcome.
Compare the applicable Discovery path against a simple baseline or disabled-path ablation under identical data and scoring.
Pin reviewed paths and public boundaries when production requires stable semantics.

Transition Discovery

Discover stable input paths and optional causal bindings.

Structure Discovery

Discover useful fields, combinations, temporal lags, and predictive rules.

Sequential Discovery

Discover state-dependent action values and delayed credit across episodes.

Complete examples

Run transition, structural, sequential, and mixed workflows.

Choose how a Domain learns

Choose Discovery paths and compatible learning methods for the observable task loop.

Get started

Concepts

Guides

Discovery

Operations

API reference

Discovery lifecycle

See adaptation in the loop

Application declarations

Choose Discovery or authored ontology

Minimal transition Domain

Inspect transition readiness

Query with current context

Extend the configuration

Production checklist

Transition Discovery

Structure Discovery

Sequential Discovery

Complete examples

Choose how a Domain learns

​Discovery lifecycle

​See adaptation in the loop

​Application declarations

​Choose Discovery or authored ontology

​Minimal transition Domain

​Inspect transition readiness

​Query with current context

​Extend the configuration

​Production checklist

Transition Discovery

Structure Discovery

Sequential Discovery

Complete examples

Choose how a Domain learns

Discovery lifecycle

See adaptation in the loop

Application declarations

Choose Discovery or authored ontology

Minimal transition Domain

Inspect transition readiness

Query with current context

Extend the configuration

Production checklist