Declared attention
What matters now?
Examine the candidates needed to decide the task. Declared bounds identify when another candidate cannot change the specified result.
Introducing MDIL Kide · Declared reasoning AI
AI that reasons with
declared knowledge.
MDIL Kide is the first release of MDIL. Declare. Reason. Keep. A model or a person declares a task once. MDIL reasons, computing the answers in order by itself and checking each one. The result is kept, so that a change redoes only what moved and another session, another AI model or a small local model can continue from it.
Knowledge in relation
Facts, relationships and conditions become a basis for reasoning.
FocusWhat matters for this task?
ExploreWhat could happen?
ReconcileDo the views agree?
ConstructWhat can be produced?
Decisions · plans · language · data
With retained knowledge and contract-specific checks.
Declare. Reason. Keep.
Wrong alone. Right with MDIL.
Then continued by a small local model.
One task, one AI model, two ways of working. The task is a long calculation: 320 steps, and an answer 511 digits long. It comes as three jobs, each in its own session: build it, pick it up, change it.
1 · The AI model alone0 of 3jobs right, in 24 turns.
Claude Sonnet 5.5, working by itself.
Claude Sonnet 5.5, working by itself.
2 · The same model through MDIL3 of 3jobs right, in 18 turns and with about half the writing.
Each answer checked by a separate program.
Each answer checked by a separate program.
3 · Then a small local model8 secondsto return the checked answer.
The big model built the work once, in 108 seconds.
The big model built the work once, in 108 seconds.
Each square is one digit of the answer: 511 in all. The 19 dark ones are as far as an ordinary computer number goes.
The frontier model is needed once, to build the structure. After that a small local model, of the kind a company can run on its own servers, takes up the work. The task is 19 times what the small model can hold at once; through MDIL its whole session fits. From the structure the frontier model published, the small model returned the exact reference of the stored, checked answer, and the separate grading program confirmed the answer behind it: the right cost and the 511-digit count.
Task runs of November 2026, graded by a separate program that reads the stored results. Full figures and methods: the system card.
A project that runs itself
Build it once.
Then state each change once.
A supply chain of 48 work stations: each station's order depends on what its neighbours order, and one change at the head moves the orders behind it. The AI model alone works the whole chain out again for every change. Through MDIL the model builds the chain once and then states each change once; MDIL reasons, computes, checks and keeps the rest.
Build once, then change30 turnsfor the build and five changes, through MDIL.
The AI model alone: 50.
The AI model alone: 50.
What a change costs20 turnsfor the five changes, through MDIL.
The AI model alone: 44, working the chain out again each time.
The AI model alone: 44, working the chain out again each time.
Only what moved is redone26 newobjects for the second version of a software repository.
1,452 kept as they were.
1,452 kept as they were.
The chain itself can come from one table. Its rows are the stations: each station's kind, the stations it serves and its own numbers. One instruction points at the columns, and MDIL builds the project, reasons out every station's order and checks it, in 150 milliseconds.
What is written910 charactersOne instruction over a table declares all 48 stations.
Written out by hand: 10,108.
Written out by hand: 10,108.
As the chain grows910 · 906 · 910characters at 12, 24 and 48 stations.
Written out by hand: 2,616, 5,121 and 10,108.
Written out by hand: 2,616, 5,121 and 10,108.
When the table changes36 of 48stations solved again after one changed number.
The other 12 keep their checked answers.
The other 12 keep their checked answers.
These three are measured in MDIL itself, with no AI model in the loop: every station's answer, before and after the change, is the one an independent calculation gives.
The same model, the same task texts, both ways; every station's answer checked by a separate program. Full figures and methods: the system card.
How it reasons
Several forms of reasoning.
A shared basis in explicit knowledge.
MDIL is a declared reasoning AI: its knowledge, relationships and permitted operations are explicit. It uses them to derive conclusions, explore possible developments and construct decisions, plans, language and data. The knowledge behind a result remains available to check, revise and use again.
A fact can support a conclusion. A condition can change which actions are possible. Several facts can become a new explanation. A shared construction can recreate a much larger artifact. MDIL makes those relationships explicit and puts them to work.
Declared trajectories
What could happen?
Explore how a situation could develop. A policy specifies what to do as information arrives; MDIL checks whether it can work using the information available at each decision.
Shared-state projections
Do the views agree?
Connect overlapping time windows through shared state. Repeated evidence stays one observation; conflicting observations are rejected.
Declared generation
What can we construct?
Build a plan or sequence, compose language from supported meaning, or recreate exact data from reusable components. Each result has its own contract.
Read the request
A declared reader turns a supported message into an explicit request. Models can also interpret open input where configured.
Reason with evidence
Determine which facts apply. Known, unknown, stale, conflicting and revoked information remain distinct.
Decide with control
Facts, relationships and priorities govern a decision, hold or review. Accepted context can support the next turn.
These are capabilities to combine as a task requires, not a compulsory sequence on every request. The system card identifies the implemented forms and their contracts.
Generation, in several forms
Construct a result.
Keep the knowledge that made it possible.
A plan, a sentence and a reconstructed file have different requirements. MDIL makes the required result explicit and constructs it from declared knowledge and permitted operations.
A plan
Steps, conditions and goals
↓
A valid continuation with its evidence.
Construct · check · reuse
Language
Meaning, facts and constructions
↓
A composed expression that preserves the content.
Construct · check · reuse
Exact data
Installed component and new input
↓
A reconstructed artifact equal to the source.
Construct · check · reuse
The connection is useful beyond a single answer: inspect the conditions, ask about alternatives, revise supported changes and invoke the capability again. People and models can develop the knowledge, and a model can work through MDIL by itself; supported declared execution can run without a model call.
See it work
Different capabilities.
Concrete consequences.
Shared observations
Repetition must not manufacture certainty.
One observation appears in several views. Treating ten copies as independent would inflate the recorded example above 99.9999%.
80% stays 80%
MDIL retains the shared source. Repeating the evidence does not add an independent observation.
Saved overlap study: 5,000 duplicate events, no probability changes from duplication; 1,000 conflicting observations rejected.
Reasoning about possible futures
A decision cannot borrow tomorrow's knowledge.
Some plans work only if a decision-maker knows the future. MDIL distinguishes these from strategies that can respond successfully as information actually becomes available.
66 hindsight-only cases identified
Across 2,835 finite cases, the study separated these from 597 robustly feasible cases and matched explicit policy enumeration.
Recorded causal-policy study. Trajectory reasoning is also implemented in current Core.
Declared language
Meaning determines what can be said.
“Pump Larch and Valve Juniper each cost €210 to service.”
Two requested facts with equal prices become one composed sentence. Different prices need distinct statements; conflicting evidence produces a conflict notice.
Recorded service-price composition and development examples. The writer constructs the expression from supported meaning and permitted constructions.
Exact reconstruction and reuse
A small transfer can carry a much larger result.
3.8 kB newly sent → 30.5 MB restored
A 944-file workspace was reconstructed exactly using a 402 kB component installed once. The shared construction gives the new input its meaning.
Recorded component-reuse result: 3,804 new bytes, 401,983 installed bytes. Working compression and reconstruction demos exist; the system card identifies them.
Capabilities connect through shared declarations and evidence. Two implemented paths show the relationship: planning constructs and checks continuations, then supports revision; language connects a request to evidence and meaning, composes an expression, checks it and retains context.
Shared declarations, task context and evidence
Plan
- Declared operations
- Construct continuations
- Check and revise
Language
- Read and bind meaning
- Compose an expression
- Check and retain context
Changing conditions: the maintenance-plan demonstration
A maintenance plan must remain feasible when staffing, windows or budget change. MDIL retains the declared operations and conditions, recomputes valid continuations and supplies checkable evidence.
A worker is unavailable
The permitted service alternative is selected.
The budget is insufficient
No feasible plan is reported before scheduling proceeds.
Inspection has a narrow window
The plan waits while preserving the required order.
Eight authored cases, four feasible and four infeasible, were checked independently. Current Core also supports repair under specified tightening changes; other changes explicitly require fresh construction. Methods and exact recorded cases: the system card.
The practical difference
The knowledge remains useful
after the result is produced.
Applications need the conditions under which an answer applies, the evidence it uses and a way to respond when either changes. MDIL makes those elements part of a reusable capability that can reason and construct again.
Inspect the basis
Explicit relationships, applicable evidence and result contracts make the reasoning available for examination.
Work with change
Retained constructions support further questions and specified revisions; changed assumptions are handled explicitly.
Combine capabilities
Use declared reasoning and construction with the models, tools and applications already in place.
Solvers and rules engines can enforce precise conditions; models can interpret open requests and propose new material. MDIL brings several reasoning and construction forms into a declared architecture, with retained knowledge and contract-specific checks.
How MDIL compares with rules engines and language models
MDIL is a declared reasoning AI. Rules are one ingredient: its declarations also describe possible developments, evidence relationships and constructions for plans, language and data. That explicit knowledge can support several operations and remain available for later work.
| Approach | Rules engines | Language models | MDIL |
|---|---|---|---|
| Primary mechanism | Match facts to rule conditions, then fire actions or derive further facts. | Generate outputs using learned patterns and the supplied context. | Reason over declared relationships, construct results under explicit conditions, and return them with the checks that path supports. |
| What it produces | Derived facts, decisions and actions specified through rules and integrations. | Open-ended text and other generated output; tools extend the application. | Decisions, possible developments, plans, supported language and exact reconstructed data. |
| What remains reusable | The rule base, working state and derived facts where supported. | The model; applications add retrieval, memory and external checks. | Declared packages, context and constructions, with operation-specific evidence and checks. |
Rules engines
- Primary mechanism
- Match facts to rule conditions, then fire actions or derive further facts.
- What it produces
- Derived facts, decisions and actions specified through rules and integrations.
- What remains reusable
- The rule base, working state and derived facts where supported.
Language models
- Primary mechanism
- Generate outputs using learned patterns and the supplied context.
- What it produces
- Open-ended text and other generated output; tools extend the application.
- What remains reusable
- The model; applications add retrieval, memory and external checks.
MDIL
- Primary mechanism
- Reason over declared relationships, construct results under explicit conditions, and return them with the checks that path supports.
- What it produces
- Decisions, possible developments, plans, supported language and exact reconstructed data.
- What remains reusable
- Declared packages, context and constructions, with operation-specific evidence and checks.
Databases provide storage and queries; constraint solvers solve explicit models. Applications can combine these approaches. MDIL connects several reasoning and construction forms through declared knowledge and evidence.
Measured serving
Prepared MDIL answers quickly,
with less repeated inference work.
The same twelve explicit service-price requests and source facts were given to prepared MDIL and a local Qwen2.5-1.5B. The comparison measured serving after preparation on one machine.
Time to return an answer68× fasterMedian over the same twelve requests
Energy for each answer99.5% lessGross chip energy for each answer attempted
Complete answers12 of 12Every requested price stated, none unsupported
Already interpreted requests; two post-run semantic reviews applied one completeness rule to both methods. Whole-application accounting also includes preparation, intake, updates and any fallback. Full method: the system card.
Additional recorded results, with the task behind each number
The research results, by workload
| Human benefit | Recorded comparison | What stayed correct |
|---|---|---|
| 17.22%less data to send Less data to send, every file restored | 46 font-metrics files reconstructed exactly: the conventional archive (USTAR with LZMA preset 6) took 91,432 bytes; the selected packet took 75,691 bytes. | Exact recovery of every file. The compressed decoder source, 3,289 bytes, is distributed separately; the collection had already been inspected during development. |
| 52.76%less repeated traffic Same records, less repeated traffic | A persistent telemetry stream in 64-record batches: the conventional route (Zstandard, then prior-content prefix reuse) sent 51,899 application bytes; the declared route sent 24,517, its installation included. | The same records delivered. Prediction, retained structure and batching carry the result on a persistent stream. |
| 67.05%less traffic, same answers Same answers with less traffic | 24 stable-query streams: exact local-delta updates sent 77,052 application bytes; selective refinement sent 25,392. | All 4,608 tested query decisions preserved in each arm. Stable queries and bounded, synchronized state. |
| 32.71%less search for the same plans Less search for the same plans | 120 finite network-planning cases: the full-state exact planner visited 1,085,202 states; the research implementation visited 730,214. | The same decisions, path counts and selected solutions in every case. Additional dependency tables were built; fewer visited states alone do not establish lower total runtime or energy. |
| 66cases needed future knowledge Planning without knowing the future | Checked against exhaustive policy enumeration across 2,835 finite planning cases: 66 cases appeared feasible only when future information was available to the decision. | Feasibility decisions matched exhaustive policy enumeration throughout. A finite model with declared disturbances; not a count of avoided incidents. |
| 3.8 kBnewly sent for a 30.5 MB workspace Reuse what the receiver already has | A repeated-component workspace of 944 files holding 30,461,218 source bytes reconstructed from a previously installed 401,983-byte reusable component plus 3,804 newly sent bytes. | Every file restored; the installation was paid once, beforehand. |
What this enables
More useful work from
knowledge already understood.
Energy for new work
99.5%
less gross chip energy per attempt than Qwen2.5-1.5B in the service-price comparison.
Safer decisions
Checks first
Check task conditions before action and retain a traceable result.
No model call on the prepared path
0 model calls
on supported declared execution paths.
AI on modest hardware
68×
faster median returned responses; the prepared MDIL path ran on a CPU.
Local data control
Run locally
Use local facts for covered work, with declared information boundaries.
Knowledge that grows
30.5 MB
restored from 3.8 kB newly sent, using a 402 kB component installed once.
Energy and response ratios use the service-price comparison above. Local execution and checks describe capabilities, with application permissions enforced at the actual resource. Reconstruction uses the installed-component study.
Use it
Bring a declared capability
into the application you already run.
01
Declare
Specify the knowledge, conditions and desired result, yourself or through an AI model.
02
Reason
MDIL reasons: it computes the result and checks it.
03
Keep
The result is stored with its check; use the decision, plan, text or data with its evidence.
04
Build on it
State a change and only what depends on it is worked out again; publish the structure and another session continues from it.
An agent can declare a task once and come back to its checked results, an application can generate grounded language, and a receiver can reconstruct data from a shared component. HTTP API access serves identified beta integrations; embedded Core is available by agreement from a versioned configuration. Each interface release identifies its supported capabilities.
MDIL Portal
MDIL Portal is the development environment where developers, integrators and enterprises build on MDIL.
Developers
The MDIL SDK and MDIL MCP open in beta with the Portal. They are the interfaces through which developers and AI models work with MDIL. Beta launches on 17 November 2026; access by agreement.
Products
REMAP turns a goal stated in one sentence into declared AI agents and loops that run a company's work on its own systems. Airut is an AI assistant for businesses and people, in the chat they already use. REMAP is in closed beta; Airut's waitlist is open.
Using MDIL well
The model declares.
MDIL reasons, computes, checks and keeps.
One request, not many
When MDIL is used as designed, one request runs the whole project and the model only makes the declarations.
A reference, not the raw data
The structure is declared once and shared by reference, so any model, even a small local one, continues from it.
Checked, traceable, reusable
For a task the model solves alone in minutes, the value is that every answer is checked, traceable and reusable, not speed.
Guidance for developers. Each case in full: the system card.
Built on research
One architecture.
Several contracts to examine.
The system card maps current Core functionality, working demos, studies and the task runs to their evidence. The technical summary explains how the mechanisms connect. The illustrated introduction provides a visual account of the same technology.
The research programme evaluates each operation and complete applications, including authoring, checking, intake, updates and useful coverage. Detailed methods and source configurations are available through controlled evaluation.
Knowledge that travels
Knowledge becomes
shared infrastructure.
People and AI create expertise. MDIL makes supported knowledge executable and reusable. A reviewed contribution can become a capability that other devices, teams and applications build on, with their own circumstances declared locally.
DEVICES
Capability close to the work
Useful reasoning and construction on modest local hardware.
ORGANISATIONS
Expertise across teams
Common knowledge with local rules and information boundaries.
INDUSTRIES
Shared foundations
Reviewed constructions that new systems can build upon.
DISCOVERY
More room for new work
Less repeated computation; each finding supports the next.
Cumulative knowledge travels, adapts and keeps creating capability: one session's published work is continued by another, and a frontier model's work by a small local model.
Join and build
Built on research.
In developers' hands from 17 November.
MDIL Kide is the first release of MDIL. MDIL launches on 17 November 2026 at 17:11 at Allas Pool in Helsinki, with three products built on it: MDIL Portal, with the MDIL SDK and MDIL MCP opening in beta, REMAP and Airut. Access to the beta is by agreement, and the Portal's own availability is announced separately. REMAP is in closed beta by invitation; Airut's waitlist is open.