NIF: when should useful work become reusable capability?
The proposed capability lifecycle, its current runtime foundations, and the experiments needed to establish dependable reuse.
Updated
Architecture under investigation, with a first controlled measurement (October 2026): one 4B coding model on one synthetic project suite. General transfer remains unproved.
Neural Intelligence Fabric · illustrative record
capability repair-config v1
- origin
- repair a failing config, project A
- scope
- dependency 2.x, Linux, read-write workspace
- observed
- config rewritten; service restarted
- accepted
- project tests pass
- kept as
- reusable procedure, scoped as above
condition changed: dependency 2.x → 3.0
Reuse is earned, and it can be taken back. A capability carries where it came from, what was checked, and the condition that ends it.
In this paper 15 sections
The question starts after a successful attempt
A system repairs a configuration and the relevant check passes. That is useful work. The harder question comes next: should the system keep a procedure from that repair and rely on it in another project? The original result may depend on a particular dependency version, environment or permission. Reusing it without those conditions can preserve a mistake as easily as a solution.
Neural Intelligence Fabric is Aditya’s research architecture for that decision. Its intended lifecycle is to discover, compose, execute, verify and then retain or reject scoped capability. It sits around a foundation model rather than replacing it. The goal is not to remember every output or let every conversation alter the model. It is to keep an inspectable connection between a reusable candidate and the evidence that supports it.
This note explains the responsibilities in that lifecycle, identifies mechanisms in the current source, and sets out what a convincing evaluation would need. It does not report a measured NIF transfer advantage. The distinction matters: implemented bookkeeping makes an experiment possible, but the experiment still has to show whether reuse helps.
A procedure, a memory and an adapter preserve different things
A written skill preserves a method. A memory entry preserves information from earlier work. A compiled adapter preserves a versioned change in model behavior. All three can contribute to a task, but they fail in different ways. A procedure can have stale prerequisites; a memory can contain a superseded conclusion; an adapter can improve one task while reducing accuracy on another.
Calling these objects capabilities is useful only if their differences remain visible. The relevant question is what each object does, what conditions it requires and what evidence justified its use. A previous successful command is not automatic permission to execute it again. A stored adapter version is not proof that activating it will improve the present task.
The intended record should therefore distinguish the reusable object from the observation that led to it. ‘This test passed on this revision’ is narrower than ‘this procedure works across repositories.’ Keeping those statements separate gives a reviewer a way to accept the observation without accepting an unsupported general rule.
- Origin
- The task, source and version that produced the candidate.
- Preconditions
- The environment and dependencies its earlier check covered.
- Authority
- The current request and permission for the specific operation.
- Observation
- What actually ran and what the operation returned.
- Acceptance
- The check that can support or reject the outcome.
- Withdrawal
- The conditions that should narrow or invalidate reuse.
Record requirements, not a claim that every current object contains complete evidence.
How to read this figure
This figure organizes the responsibilities and evidence discussed in this section. It is a conceptual explanation, not a measured runtime trace, a benchmark or a claim that every mechanism has been validated end to end. Read the source inventory and research limits alongside it.
Source inventory and boundariesDiscovery finds candidates; it does not select a winner
The current capability registry unifies metadata from native tools, configured MCP tools, skills and registered units. It ranks candidates using keyword and metadata overlap. This is symbolic discovery, not a learned router over neural capability embeddings. A relevant-looking result is a candidate for inspection, not an established best action.
That boundary is useful in practice. Discovery can narrow the material presented to the model while leaving suitability and authorization open. Inspect the candidate’s provider, version, health, trust, permissions and schema. Then compare those fields with the actual operation being considered. Static tool metadata cannot fully describe the risk of a shell command whose arguments have not yet been chosen.
Registration and retrieval do not themselves execute the capability. Execution needs its own policy decision and result record. A future learned router would require its own evaluation of selection quality, unsuitable activation and behavior on unfamiliar tasks. It cannot be inferred from the existence of today’s metadata index.
Compose around the task’s present conditions
A saved method may be appropriate for one repository and wrong for a superficially similar one. Before composing a run, compare the present task with the candidate’s prerequisites. Which files and tools are available? Which dependency versions matter? What did the operator ask to change, and what did they ask only to inspect? A description that matches the vocabulary of the task can still miss its cause.
Relevant context should carry both supporting and contradicting evidence. If a previous procedure assumes a local database but the current project uses a remote service, that mismatch belongs in the decision. If the current request excludes writes, a stored repair procedure cannot widen that authority. Composition is not merely choosing pieces that can technically connect; it also means checking whether they belong in this run.
The full research question is whether a system can make these choices dependably. The current mechanisms allow scope and observations to be represented, but this note does not claim automatic suitability assessment is solved. Changed environments and narrowed permissions are important negative cases for a later evaluation.
- 01
Discover
Find an existing candidate.
- 02
Inspect & compose
Match scope to the current task.
- 03
Execute
Apply policy and preserve observations.
- 04
Verify
Exercise the acceptance criterion.
- 05
Retain or reject
Keep only a justified, bounded record.
A failed check can return the task to investigation. This is a method diagram, not a measured live trace.
How to read this figure
This figure organizes the responsibilities and evidence discussed in this section. It is a conceptual explanation, not a measured runtime trace, a benchmark or a claim that every mechanism has been validated end to end. Read the source inventory and research limits alongside it.
Source inventory and boundariesPreserve what happened, including the failed attempt
A proposed operation, an executed operation and a successful outcome are different events. The model may propose reading a file that does not exist. A command may finish without testing the behavior the operator cares about. A service may time out after accepting a write. The record needs to preserve the actual observation rather than replacing it with the expected result.
Failures are useful when they can change the next decision. An unavailable tool may require another source or a clear blocker. A failed assertion may challenge the proposed repair. A timeout on a consequential action should prompt inspection of state before retrying. Repeating the same operation without using its result does not turn a long trace into progress.
The example of a configuration repair in this note is illustrative, not an unpublished successful NIF run. In a real experiment, preserve the input conditions, allowed operation, observations and verifier outcome. Without that record, a later retention decision rests on a story about the attempt rather than evidence from it.
Verification must be able to reject a convincing result
A useful verifier checks the requested outcome, not the fluency of the explanation. For a repair, a regression test should reach the broken path and be capable of failing when that path is still wrong. A process exit code can support a narrower observation—such as a command completing—but it does not automatically establish that the task was satisfied.
The current completion logic inspects recorded verification, open acceptance criteria, unfinished work and unresolved approvals. It can challenge a completion proposal when the most recent check failed or a change lacks verification. These are runtime mechanisms. Their effectiveness still depends on the chosen criterion, the quality of the check and the evidence stored in the run.
A passing local check can justify a bounded conclusion. It cannot establish that the procedure transfers to every environment, or that retaining it is harmless. Verification of the first attempt and evaluation of later reuse are separate steps; the latter must include cases that the first test never exercised.
Retention should add a boundary, not a permanent privilege
Once a run is checked, the next decision is what to retain. Sometimes the useful result is an observation, not an executable procedure. Sometimes a procedure should remain a draft because its prerequisites cannot be established. Rejection is a meaningful outcome: a system that keeps every candidate has accumulated material, not demonstrated governed reuse.
A proposed retention record should include origin, supported scope, relevant versions, the acceptance check and reasons to withdraw it. These are inspection requirements, not a claim that every current object contains a complete laboratory record. New evidence should be able to narrow the scope rather than silently inherit the broadest previous interpretation.
Approval for one operation also must not become standing approval for future operations. A later task may involve a different project, different people or an external service. Apply the present permission policy again. Reuse may save investigation effort; it should not remove the decisions needed to authorize the action.
The adapter ledger records versions, not task superiority
The reversible adapter bank tracks compiled versions, base-model compatibility, declared rank, measured norm metadata, activation and rollback history. It is a ledger, not a model loader. Tensor compilation and measurement occur in separate code. Recording a norm policy decision is different from proving that the resulting behavior is useful on the task.
An adapter should be evaluated in isolation and, where composition is intended, in the combinations that will be used. A measured improvement for one unit does not establish that combining it with another preserves that improvement. Compatibility metadata helps identify conditions to inspect; it is not a substitute for a composed-behavior evaluation.
The present source supports concrete questions about version identity and activation state. Broader questions about transfer, interference and consolidation remain experimental. We keep those statuses visible so that a diagram of the architecture cannot be mistaken for a reported capability result.
Mechanisms in the source
- Symbolic capability discovery
- Recorded state, policy and completion checks
- Adapter version and activation ledger
Questions requiring experiments
- Reliable selection on unfamiliar tasks
- Useful transfer and composed behavior
- Dependable withdrawal and consolidation
A qualitative status summary from inspected code. There is no readiness percentage or measured transfer score implied.
How to read this figure
This figure organizes the responsibilities and evidence discussed in this section. It is a conceptual explanation, not a measured runtime trace, a benchmark or a claim that every mechanism has been validated end to end. Read the source inventory and research limits alongside it.
Source inventory and boundariesWithdrawal needs a test of its own
Disabling a procedure, withdrawing a memory entry and deactivating an adapter are different operations. Each can affect dependent records or active runs. A rollback ledger can identify the intended previous version without proving that every surrounding system has returned to its previous behavior. The test must exercise the relevant state, not only confirm that a history entry was appended.
For a reuse experiment, include a capability later found to be unsuitable. Check whether new tasks stop selecting it, whether affected records remain inspectable, and what happens to a run already using it. Also inspect unrelated capability: withdrawing one candidate should not be described as clean merely because its own flag changed.
These are proposed evaluation cases, not reported successful rollback trials. They make reversibility concrete. The goal is an operator who can see what was withdrawn, why, and which effects remain uncertain. A silent switch to another candidate would hide the evidence that should have changed the system’s trust.
Test reuse, transfer and abstention separately
Begin with a controlled first-use versus reuse comparison on the same task conditions. Record correctness, inspection cost and recovery from failure separately. Faster discovery is useful, but it is not the same result as better task completion. A run that avoids one search while producing a wrong repair has not established a reuse advantage.
Then test changed conditions and unfamiliar tasks. Include cases where the correct decision is not to activate the saved candidate: a missing prerequisite, a different cause, a changed dependency or a narrower request. Record unsuitable activation and correct abstention alongside successful reuse. Otherwise the evaluation rewards selection without examining whether the selected capability belonged in the task.
Finally, challenge withdrawal and composition. Use explicit baselines and preserve unsuccessful attempts. The language-accuracy results elsewhere on this site do not answer these questions merely because they belong to Aditya. A NIF claim needs a NIF experiment with its own task definition, denominator and evidence. The next section reports the first one.
First measurement: reuse beat retrieval, a connector and a skill on one suite
The experiment uses a synthetic project with ten private team conventions: a refund channel name, a retry policy, a customer checksum rule, a billable-weight formula and six more. No model can know them in advance. Each arm runs the same coding agent, a 4B model at temperature 0.3, on the same ten tasks, three trials per convention. A hidden check grades the file the agent writes. The arms differ only in where the conventions live: nowhere, project documents the agent can search (RAG), a documentation server it can query (MCP), a trusted project skill holding every convention, or a NIF recipe recorded from one earlier verified run on that convention.
In the final run NIF succeeded on 28 of 30 trials (93%; 95% interval 79–98%). MCP succeeded on 21 (70%), the skill on 13 (43%), RAG on 8 (27%) and the arm with no source on 0 of 10. Successful NIF trials took 1.8 tool steps on average, against 3.4 for MCP and 4.5 for RAG. The ordering held across five runs on the same day: NIF 24 to 30 of 30, MCP 17 to 21, the skill 12 to 13 once the runtime trusted it, RAG 5 to 11. Every recipe NIF offered came from the convention under test.
Changed conditions are where reuse is most likely to mislead, so they were tested separately. On a sister project where part of an old recipe no longer applies, NIF succeeded on 8 of 9 trials and RAG on 4. When the team changed three conventions after NIF had learned them, and the documents stated the new values, NIF first scored 2 of 9 and 5 of 9 in two runs: a verified old recipe sometimes beat the current documents. A recipe now records a fingerprint of the files it read, and says when one has changed and must be re-read. With that, one run scored 6 of 9 against RAG's 1 of 9. That is an improvement in one run, not an established fix.
NIF can also hold knowledge no document contains. With no documents anywhere, the agent was told what was wrong after a failed first attempt, for example that the refund channel is a different name. That correction became part of the recorded recipe. On the later tasks NIF succeeded on 30 of 30 trials.
Successful trials (%)
NIF
- 93.3%28/30
MCP
- 70.0%21/30
Skill
- 43.3%13/30
RAG
- 26.7%8/30
None
- 0.0%0/10
Whiskers: saved 95% Wilson intervals. Ten conventions, three trials each; no-source used one trial per convention. A hidden check grades the written file. One synthetic suite, not a universal ranking of architectures.
| Test | NIF | RAG |
|---|---|---|
| Near miss: a sister project where part of the old recipe does not apply | 8/9 | 4/9 |
| Updated conventions: the team changed three rules after NIF learned themBefore the stale-source check: NIF 2/9 and 5/9 in two earlier runs (RAG 5/9 and 3/9). | 6/9 | 1/9 |
| Learned from user corrections alone, no documents anywhere | 30/30 | not run |
Across five runs the same day, NIF scored 24 to 30 of 30; MCP 17 to 21; skill 12 to 13 once the runtime trusted the project skill; RAG 5 to 11. Two runs' retrieval-precision field was mis-scored by the comparison script (a task-name prefix); recounted from the saved trials. Success counts were not affected.
View methods and limits
Each bar counts successful trials out of attempted trials in the final run: 10 conventions, 3 trials each, graded by a hidden check on the file the agent wrote. The arms share the model, tasks, temperature and step budget; only the location of the conventions differs. The arm with no source ran one trial per convention. Intervals are 95% Wilson intervals, given in the text. This is one synthetic suite and one model, not a public benchmark.
Why reuse won, and the limitsWhy reuse won here, and where the result stops
The saved trials point to one main cause. The other sources only help if the model decides to look. Of RAG's 22 failed trials in the final run, 20 never consulted the documents before writing: half wrote a guessed value and half wrote nothing. When the RAG agent did look first, it succeeded on 7 of 9 trials; the MCP agent succeeded on 21 of 23. NIF removes that decision. The recipe arrives with the task and shows what already passed the check: the changed file in its final form and the lesson from any correction. In 21 of its 28 successes the agent wrote the correct file without looking anything up. That is the advantage, and it is also the risk: a recipe that no longer applies arrives with the same confidence.
The limits are substantial. This is one 4B model on one synthetic suite of ten conventions, designed by the team that built NIF. Thirty trials per arm leave wide intervals: NIF's lead over RAG and the skill is clear, while the intervals for NIF and MCP overlap. Recipes are reused on the project family they were learned on, so this measures reuse, not general transfer to unfamiliar tasks. The updated-conventions case still fails a third of the time. The external-model runs are single comparisons on one suite; no public benchmark has been run. While reviewing the saved records, a retrieval-precision field was found mis-scored in two runs by the comparison script and was recounted from the saved trials. No success count changed.
On other models, the accuracy lead closes as the model gets stronger
The same suite was run on three OpenAI models through an API, with the same tools and graders. The tools were offered as native functions, because the text format our models use was at first not recognised as callable; three runs were discarded for problems in our own harness before any result was kept. The table shows every trial that ran.
On gpt-5.4-mini, NIF succeeded on 29 of 30 trials, project documents on 24, the documentation server on 4 and the skill on 2. The mechanism matched the 4B: the model used the documentation server in only 3 of 30 trials and passed all 3. On gpt-5.5 every source worked in the one round that ran before the API credits ran out. On gpt-6.1-sol, the newest model tested, every source succeeded on 29 or 30 of 30, and NIF needed 5.4 tool steps against 7.0 to 8.3 for the others.
The pattern across five models is consistent: NIF gives the largest accuracy gain where a model would not go and look for the knowledge, which describes small and mid-size models; on a flagship that always looks, accuracy is equal and NIF does the same work in 23 to 35 percent fewer steps. Corrections a user gives remain knowledge that no document, server or skill holds.
Successful trials (%)
NIF
- 96.7%29/30
RAG
- 80.0%24/30
MCP
- 13.3%4/30
Skill
- 6.7%2/30
None
- 0.0%0/10
3 per convention. Used the documentation server in 3 of 30 MCP trials (all 3 passed) and the skill in 3 of 30. Searched project documents in all 30 RAG trials.
Successful trials (%)
NIF
- 100.0%10/10
RAG
- 90.0%9/10
MCP
- 100.0%11/11
Skill
- 90.9%10/11
None
- 0.0%0/10
1 per convention (stopped when API credits ran out). Looked the conventions up in almost every trial.
Successful trials (%)
NIF
- 100.0%30/30
RAG
- 100.0%30/30
MCP
- 100.0%30/30
Skill
- 96.7%29/30
None
- 0.0%0/10
3 per convention. Every source worked; near-miss and updated-convention tests 9/9 for NIF and RAG alike.
| Model | NIF | RAG | MCP | Skill | None |
|---|---|---|---|---|---|
| gpt-5.4-mini3 per convention | 29/30(4.6 steps) | 24/30(5.6 steps) | 4/30(9.0 steps) | 2/30(7.5 steps) | 0/10 |
| gpt-5.51 per convention (stopped when API credits ran out) | 10/10 | 9/10 | 11/11 | 10/11 | 0/10 |
| gpt-6.1-sol3 per convention | 30/30(5.4 steps) | 30/30(8.3 steps) | 30/30(7.5 steps) | 29/30(7.0 steps) | 0/10 |
The same suite, tools and graders on OpenAI models through an API (tools offered natively; calls converted to the same format). October 2026.
View methods and limits
Same ten conventions, tools and hidden checks as the 4B experiment. Tools were offered as native functions and each call was converted to the agent's own format, so every model used identical tools. gpt-5.5 ran one round before the API credits ran out; the trials that never ran are not counted. Single comparisons on one suite, not a public benchmark.
Read the full comparisonBeyond the agent: reusing a verified answer in chat
The same lifecycle was applied to the general chat model. When a maths question is asked for the first time, the model answers it twice, once directly and once with thinking; the answer becomes a recipe only if both give the same number, without consulting any answer key. When the same question returns in another language, the recipe is offered with the question, and the model is asked to check that it applies.
On 349 such repeated GSM8K-Indic questions, NIF answered 88.0 percent correctly, against 82.5 percent for the plain model and 84.8 percent with thinking. Against the plain model the gain is significant: on the same questions NIF fixed 26 answers and broke 7. Against thinking it is not yet settled. NIF used 46 thousand tokens where thinking used 250 thousand, and answered in a median of 5.1 seconds against 23.6.
Two problems keep this a research result, not a product feature. Recipes were matched by the numbers in a question, and 21 of 508 unrelated questions happened to share a recipe's numbers; given that wrong recipe, the model did not notice, and those questions fell from 18 to 9 correct. And 17 of 228 verified recipes were wrong, because two answers can agree on the same wrong number. A meaning check has since been added and measured: wrong matches fell from 21 of 508 to 0, and later runs show NIF matching thinking mode rather than beating it. The full account is in the dedicated note on reusing a verified answer in chat.
Accuracy (%)
Plain
- 82.5%288/349
Thinking
- 84.8%296/349
NIF
- 88.0%307/349
| Setup | Correct | Tokens | Median time |
|---|---|---|---|
| Plain | 288/349 | 73k | 8.9 s |
| Thinking | 296/349 | 250k | 23.6 s |
| NIF | 307/349 | 46k | 5.1 s |
NIF vs plain: 26 questions fixed, 7 broken (exact p = 0.001). NIF vs thinking: 28 vs 17 (p = 0.14, not settled). Known problems: 21 of 508 unrelated questions shared a recipe's numbers; given that wrong recipe, the model did not notice and those questions fell from 18 to 9 correct. 211 of 228 'verified' recipes were correct (93%): two answers can agree on the same wrong number.
View methods and limits
GSM8K-Indic questions that appear more than once in different languages. The first appearance is answered directly and with thinking; it becomes a recipe only if both give the same number. Later appearances are answered three ways on the same questions. Answers are compared with the reference number; significance is an exact paired test on the questions where the two setups differ. One model and one suite; recipes were matched by the numbers in a question, which is not safe enough for users yet.
Read the problemsCurrent limits and inspectable sources
NIF is a research direction with real implementation foundations. Symbolic discovery, run state, policy, completion checks and adapter bookkeeping can be inspected in the source. A learned router, dependable general transfer and automatic consolidation are not established by those modules. The first controlled comparison above measured an advantage for reuse on one suite and one model. That is evidence for the approach, not a proof of the thesis.
Read the registry and adapter-bank module descriptions alongside the completion code. They state important scope boundaries, including what metadata retrieval does and what the adapter ledger does not load or measure. The accompanying journal note explains the same concept in a shorter educational format. The separate Stage R v8 report contains measured language-task results, with its own limitations.
Sources and related evidence
Internal sources — implementation review of symbolic capability metadata retrieval.
Internal sources — implementation review of capability versions and activation records.
Internal sources — implementation review of evidence-based completion decisions.