Approach // REI Core

Core is a self-contained reasoning substrate. Its state changes as it is used. Each query enters a persistent field that already holds concepts, constraints, bindings, examples, procedures, corrections, and unresolved candidates.

Active structures in that field compete for support. Well-supported ones strengthen, conflicts get resolved or carried, and weakly supported candidates stay provisional. Core returns the answer together with the formation that produced it: what activated, what conflicted, what resolved, what remains missing, and what changed for the next query.

core / formation viewinspecting

view sections

evidenceactivationsupportconflictresolutionhypothesesexpectsmissingcarryover

The query enters a field that already has shape.

Before an answer forms, the substrate already has shape. Concepts have activation depth, bindings have strength, constraints press against candidate structures, and local procedures carry prior contribution.

A query perturbs the current field. Several structures become active at once and compete for support. The answer appears once the field settles enough to expose a stable surface.

Core can represent knowledge as graph-like, symbolic, vector, temporal, or domain-specific structures. What a query exposes is the formation built over persistent state as active structures compete. The run does not walk a graph.

Core forms working formations before it answers.

When a query enters, related concepts, constraints, bindings, examples, procedures, corrections, and prior failures become active together. Candidate formations appear, explaining different parts of the input, and some of them conflict.

The formation is a working structure inside the substrate. Its useful parts stabilize and stay. Weak parts fade. Corrections change what future queries activate.

Domains become local operating regimes.

A domain is a learned operating regime inside the substrate. Entities, signals, constraints, procedures, corrections, failure modes, and hypotheses reinforce each other through exposure. It is not a folder of documents or a prompt context.

As exposure accumulates, Core has less to reconstruct for each query. A query wakes an already-shaped field where useful structures have consolidated and weak signals have faded. Corrections change what the substrate is likely to activate next.

The answer is only the visible surface.

Under the answer, Core has activated evidence, candidate structures, weighted procedures, conflicts, resolutions, carried uncertainty, expected observations, missing observations, and substrate change.

The output can be a direct answer, or an unresolved state with a reason to wait. The run leaves an inspectable formation that records what supported the answer, what conflicted, what resolved, what remains missing, and what changed for the next query.

input pressure

maintenance window / sensor contradiction / final titer loss

surface

Restricted feed delivery is the current best explanation

carryover

↑restriction relation reinforced↻feedpump.uses binding revised•sensor masking held provisional↓weak contamination candidate fades

Formation stays in the loop.

Core is built for direct, low-latency use. On the direct Core path, observed runs are typically in the tens of milliseconds, roughly 200ms–2s in current local/runtime conditions.

That matters because the formation stays close to the run that produced it. The answer, active structures, conflict, resolution, expected observations, missing observations, and substrate delta arrive together with it.

An instance can be queried, inspected, corrected, and queried again while the substrate is still the object of work.

The substrate is the system.

Core can be reached through chat, API calls, agents, logs, or embedded workflows. These surfaces format and relay information. The reasoning happens in the substrate underneath them.

The substrate holds the structure that gets formed, revised, stabilized, forgotten, and inspected. The same instance can answer as a machine-readable payload or in plain language, and swapping the interface does not change what the instance holds.

fig 05.a direct surfacesys.api

Adapt-1

Direct onto the substrate / API

Adapt-1 exposes the instance as a first-class object. You spawn it, feed it, query it, and read the formation view: active structures, support, conflict, resolution, hypotheses, expected observations, missing observations, and substrate change.

const instance = await core.instance("bioprocess-ops");   // your persistent instance
await instance.ingest("./bioprocess.kb");          // records, events, corrections

const r = await instance.ask({
  query: "why did yield fall after the maintenance window?",
  formation: true,
});

// r.answer + r.formation returned together
{
  answer:    "...",
  formation: {
    evidence:   5,
    candidates: ["feed_restriction", "sensor_masking", "contamination"],
    conflict:   "feedpump.uses: standard_tubing | narrow_tubing",
    resolution: "narrow_tubing",
    expects:    ["lower_substrate", "lactate_rise"],
    missing:    ["feed_rate_measurement", "calibration_report"],
    carryover:  ["binding_revised", "restriction_reinforced"],
  },
}