GitMir Lab · Current work · 01

intelligance

An intelligence layer above agents. Not an agent and not a framework — an intermediate layer that takes a task in natural language and returns a verifiable artifact: a typed tree of meaning with computed confidence.

STAGE WORKING PROTOTYPENODE TYPES 16 · CLOSED LISTEDGE TYPES 18 · COMPOSITION RULESREFERENCE TEST PASSES ON MOCK, NO NETWORK
Thesis

Intelligence is the ability to ask the next question.

The knowledge is already inside the model; what the model lacks is the discipline of interrogating itself. So here the model does not "think" — it answers. Intelligence is moved outside: into the interrogation procedure and into the graph where answers accumulate. Two consequences carry the whole design:

  • Context lives in the graph, not in the model window. At every step the model sees only the current node, the path to it and the frame of the scene. Task size is bounded by a question budget — not by context size.
  • The alphabet is finite. Node and edge types are closed lists, and composition rules are checked mechanically. A parse can be validated, diffed between versions, and an error localized to a specific node — instead of "trusting the model".
The ontology

Closed alphabets, mechanical rules.

AlphabetMembers
Node types (16)MECHANISM · PROCESS · FLOW · ENTITY · PLACE · STATE · EVENT · CONDITION · CONSTRAINT · EFFECT · RISK · FACT · CLASS · QUESTION · CONCLUSION · GOAL
Edge types (18)DECOMPOSES_TO · HAS_PART · PERFORMS · PRODUCES · CONSUMES · FLOWS_TO · LOCATED · AFFECTS · CAUSES · TRANSFORMS_TO · REQUIRES · INSTANCE_OF · KNOWN_FOR · INTERSECTS · ASKED_ON · ANSWERS · CONCLUDES · EVALUATED_AS

Every edge type declares which node types it may legally connect. An illegal edge is a parse error, not a footnote. The lists are closed in the moment but not frozen forever — extension is an explicit operation, never a side effect of parsing.

Modality: confidence is arithmetic

An edge carries not the fact of existence but the degree of necessity: certain 1.0 · likely 0.7 · conditional 0.5 · possible 0.4 · rare 0.15. A conclusion's confidence is the product of weights along its path. "Probably mold" is produced by arithmetic — not by a hedge the model added.

The operators

A finite set of questions.

The procedure interrogates the model with a closed set of operators; each builds a specific kind of edge.

OperatorQuestionBuilds
decomposeWhat is this mechanism made of?DECOMPOSES_TO
processesWhich processes run while it works?PERFORMS
productsWhat does the process produce?PRODUCES
routingWhere does the flow go?FLOWS_TO
spatialWhere is the object located?LOCATED
timelineWhat does the state turn into over time?TRANSFORMS_TO
abstractWhat is this a special case of?INSTANCE_OF + KNOWN_FOR
impactHow bad is it, and is it reversible?EVALUATED_AS
preconditionUnder which conditions does it happen?REQUIRES
interactionWhat happens when two branches meet?CAUSES

Three carry the main load

  • abstract — the abstraction lift. Knowledge lives at the level of the class. The model holds no fact about "mold on the sofa under this air conditioner" — but it does about damp surfaces. You must climb up, take the knowledge, and come back down.
  • The completeness pass — not a separate operator but a mandatory second round of every expansion: "is that the only option — what else?". Without it, parsing stops at the first plausible answer, the model's core disease. In the reference task it is this pass that surfaces the abnormal condensate path, without which mold is never reached.
  • interaction — closing the branches. Non-obvious conclusions are not born deep inside one chain; they are born where independently grown branches meet. Intersections are computed on the graph — not guessed.
Deterministic context

The same graph yields byte-identical context.

The model answers as well as it understands what it was asked about. "Where does the condensate go?" in a vacuum yields an abstract answer about drainage; the same question with a path and a scene yields an answer about this installation. The context block is assembled from the graph deterministically — the same graph produces a byte-identical block, otherwise there is neither reproducibility nor cacheability. The block carries: the goal of the parse, the scene, the participants, the path to the node, what is already known about the node, and what was found nearby on the same step.

Controlling expansion

  • Prioritization: the target question works as a gradient — branches that do not lead toward the goal sink in the queue. Without it the graph explodes at the third level: an air conditioner also has vibration, noise, icing and rust.
  • Termination: a question budget, depth, a significance threshold, and "dry rounds" — K expansions in a row that add no new nodes mean the parse is exhausted.
The artifact

What is handed over.

FieldContents
graphThe full object model; a flat, diffable JSON serialization.
conclusionsFindings: text, the reasoning chain, confidence, risk.
validationMechanical composition check — ok plus the list of issues.
traceEvery step: what was asked, what came back, where branches closed.
statsGraph size, questions asked, stop reason, token spend.

The layer does not manage execution: it hands over the artifact, and other agents execute it. The reverse channel — execution results refining the parse — is the next step.

Reference task

An air conditioner, a balcony, a sofa. The answer ("mold") is hardcoded nowhere: the mock provider only answers local questions and does not know the task. The engine must assemble the conclusion itself — and does, with its confidence computed as the product of edge weights along the path.