01 What this initiative is
One goal, three processes, evidence before generalization at every step.
The DrezTek Efficiency Initiative names the ongoing effort to make DrezTek's AI-driven applications fast, safe, and eventually interoperable — without asking a model to do work that ordinary code already does more reliably. It groups three processes that solve three different parts of that problem:
In scope
- Deterministic-first request routing (NRP)
- A standardized, validated envelope for a resolved intent (AIOL)
- Bounded, epistemic-status-aware context delivery (Context Capsules, an AIOL structure)
- An existing shared intelligence layer used by Appnizer, Vibr, and Sentinel (DIL); Naro and AIOL integration not yet established
- Live Intelligence Views — the deterministic pre-computation layer that makes the Resolution Ladder's zero-model-call reads possible; real, shipped infrastructure the other three processes build on, not evaluated as a fourth per-module completion criterion (Section 9)
Out of scope, for now
- A public AIOL release, SDK, or hosted schemas
- Any second real application consuming an AIOL envelope
- New DIL expansion, or a Naro–DIL integration, before the three existing DIL deployments are inventoried (Section 4)
- Claims of universal AI-to-AI communication
Each process below is explained on its own terms, with its own summary and intentions, so it's clear which one a given claim — or a given benchmark number — is actually about.
What counts as "module complete"
A module (Tasks, Events, Groceries, or a future one) is complete under this initiative when it has adopted every DEI process that would add real value to it — not every process unconditionally. Leaving out a process that would add value means the module isn't complete; leaving out one that has no evidenced use for that module isn't a gap, it's the correct call. Applied per process:
- Resolution Ladder (NRP) — needed whenever a module has a common, unambiguous phrasing that a deterministic parser could resolve without a model call. Its absence is a real gap if such phrasing exists and still pays for a model call every time.
- Context Capsule (AIOL) — needed only when a module has a real read/recall need a model must reason over (ranking, search, disambiguation). A create-only module with nothing to look up has no gap for lacking one.
- Guarded Execution (AIOL validate-before-write) — needed on every real write path a module has, with no exception. Any path that reaches a write ungated is always a gap, never an acceptable omission.
- DIL — not evaluated per module today. It isn't connected to any Naro module yet, so its absence is a Naro-wide integration question (Section 4), not evidence against any one module's completeness.
Under this test, all three modules have now reached completion. Events and Groceries (Phase 13): Resolution Ladder live for their plain, common phrasing; Guarded Execution already complete on every real write path, before and after; no evidenced Context Capsule need. Tasks (Phase 15): its one remaining gap — the model-tool-loop's update_task/create_task fallback writing with no AIOL gate — is closed; see Section 3 for exactly how. DIL doesn't apply per module for any of the three. This is a snapshot against currently-evidenced value, not a permanent guarantee — a future real search/recall need for any module would reopen its Context Capsule question specifically.
02 NRP — Naro Request Resolution Pipeline
How Naro decides what a request means, and whether a model needs to be involved at all.
NRP
Partially liveSummary: a request either matches a known, narrow shape — and is handled by deterministic code with no model call — or it falls through to a full model tool-calling loop. Intention: most of a real conversation's cost and latency should come from unavoidable model reasoning, not from routing every request through a model regardless of how simple it is.
NRP is the architecture produced by Naro's own internal deliberation process (previously called "the Council decision"). It is Naro-specific today — nothing about it is a public standard or a claim about how other apps should work. It has four parts:
- Resolution Ladder — deterministic code first, a defined multi-step skill when a known procedure applies, a model only when the phrasing is genuinely unclear or novel.
- Context Capsule — a bounded, relevant slice of data handed to a model when one is needed, never the user's full history (an AIOL-defined structure — see Section 3).
- Epistemic Control — every piece of context is marked FACT (confirmed), RECALL (candidate, unconfirmed), or REVIEW (named, no producer exists yet) — and RECALL material is guarded from ever reaching a write step without an intervening confirmation.
- Guarded Execution — validate first, commit last: an ambiguous or unresolved reference is refused or clarified, never guessed; a write re-checks its target hasn't changed since it was looked up.
Six intents currently pass through some version of the Ladder: task.complete, task.reschedule, task.create (fast path only), event.create, grocery.add, and grocery.restock. One Context Capsule is live (Section 5). Everything else — the large majority of what Naro can do — still falls through to the full model loop, unchanged from before NRP existed. The Ladder's zero-model-call reads (plain "what's due today" style questions) are themselves backed by a deterministic view-computation layer, Live Intelligence Views — documented on its own terms in Section 9, since it's real, shared infrastructure rather than a Ladder step itself.
03 AIOL — AI-Oriented Language
The standardized contract used at some of NRP's boundaries — not a replacement for it, and not another reasoning step.
AIOL
0.1, experimental — complete coverage on all six routed intentsSummary: once NRP's Resolution Ladder decides what a request means, that meaning is expressed as a small, versioned, schema-validated JSON envelope instead of a private, per-application data structure. Intention: a resolved interpretation should be reusable — testable, versionable, and eventually consumable by a second application — without asking a model to reinterpret the original request.
AIOL does not add a reasoning step and does not replace NRP's deterministic resolvers — it validates the output of a resolver, immediately before a write, and standardizes the structure of a Context Capsule. The governing rule: probabilistic interpretation, deterministic validation and execution. A model (or a deterministic parser, when the phrasing is unambiguous) may propose what a request means; only schema-validated, deterministic code ever executes it.
The specification itself — schemas, conformance tests, per-vocabulary docs — lives in its own repository, kept intentionally separate from this initiative-level page so it reads as a standalone, portable contract: dreztek/aiol. That repository is the canonical source for the envelope shape, the Tasks/Calendar/Grocery/Context vocabularies, and how to adopt an optional compatibility field (e.g. Task's position/category, Grocery's existing-item detection) in a completely independent application.
Exact coverage, per intent
All six intents touch AIOL somewhere. Only three have every real path to that write gated — the other three have a second, ungated route that reaches the same write through the model's general tool-calling loop. Verified directly against the dispatch code, not assumed:
| Intent | Narrow deterministic path | Model tool-loop path | AIOL coverage |
|---|---|---|---|
| task.complete | Live, AIOL-validated (try_dispatch) | Live (Phase 15) — update_task(is_done=True) now produces a confirm-gated proposal, AIOL-validated on confirm via the same envelope machinery | Complete — both paths end in the same validated write |
| task.reschedule | Live, AIOL-validated (try_dispatch) | Live (Phase 15) — update_task(due_date=...) now produces a confirm-gated proposal, same as above | Complete — both paths end in the same validated write |
| task.create | Live, AIOL-validated (try_direct_action) | Live (Phase 15) — the model-loop's create_task now always produces a confirm-gated proposal (moved to PROPOSAL_TOOLS), AIOL-validated on confirm before the real write | Complete — both paths end in the same validated write |
| event.create | Live (Phase 13, try_direct_create_event) — narrow "add an event called X [today|tomorrow] [at TIME]" shape only, still produces a proposal, never writes directly | Everything outside that narrow shape (location, unrecognized dates, anything else) | Complete — both paths end in the same human-confirmed, AIOL-validated write |
| grocery.add | Live (Phase 13, try_dispatch's new branch) — narrow "add/put/need X to/on/for … (grocery|shopping) list" shape only, still produces a proposal, never writes directly | Everything outside that narrow shape, including bare "my list" (kept ambiguous with Tasks' own lists on purpose) | Complete — both paths end in the same human-confirmed, AIOL-validated write |
| grocery.restock | Live, AIOL-validated resolution (try_dispatch) | Unmatched phrasing falls to grocery.add instead — still gated, just without restock's fuzzy-match benefit | Complete — no ungated route exists |
All six intents now follow the same rule: event.create/grocery.add's deterministic shortcuts (Phase 13) were built to still end in a human confirm and the same validated write; the three Tasks intents' model-tool-loop fallback (Phase 15) now does too, via a new confirm gate on update_task's is_done/due_date fields and on the model-loop's create_task. Completeness was never "has a shortcut or doesn't" — it's whether every path, shortcut included, still ends at the same gate. It now does, everywhere.
Three different things "model-originated AIOL" could mean — only one is real today
It matters precisely which of these is true, so all three are named rather than left to blur together:
- A — model proposal converted to AIOL: the model calls a tool with some arguments → that exact proposal is converted into an AIOL envelope → a human confirms it unmodified → the envelope is validated → the write happens.
- B — human-re-entered data creates AIOL: the model suggests an action, but a human separately edits or re-enters the structured data before anything becomes AIOL — so the AIOL envelope reflects the human's data, not the model's own output.
- C — the model emits AIOL directly: no proposal/tool-call step at all; the model itself produces a schema-shaped envelope, which is then validated and executed.
Condition A is already real today — traced directly in the frontend and backend code, not inferred: event.create's and grocery.add's confirm cards render a plain text summary and Confirm/Cancel buttons with no editable fields anywhere; confirming sends the exact proposal object the model's tool call produced, byte-for-byte, to execute_confirmed_action, which is what converts it into an AIOL envelope and validates it. So the earlier framing on this page — that closing task.create's gap "would be the first time an AIOL envelope is built from a model's own tool proposal" — was wrong, and is corrected here: that proof already exists, for two of six intents. Condition B is not implemented anywhere in this codebase; there is no flow where a human edits data before it becomes AIOL. Condition C is confirmed not built anywhere either. Update (Phase 15): Condition A is now proven for all three Tasks intents too, the same way — the model's own update_task/create_task tool-call arguments flow unmodified into the confirm card and, on an unedited tap, into the AIOL envelope.
Update (Phase 15): the choice named above — extend Condition A's already-proven confirm-gate pattern to Tasks, or validate-and-write with no confirmation at all — is resolved. Tasks now uses the same confirm-gate pattern event.create/grocery.add already had, via one shared interception point around update_task/create_task rather than three separate fixes. All six intents now end in the same human-confirmed (or, for the three narrow deterministic paths, precondition-checked), AIOL-validated write.
04 DIL — Existing shared intelligence layer; Naro integration pending
Not a future component — a running one. What's actually open is whether Naro connects to it, and whether it can supply anything AIOL-shaped.
DIL
Active in Appnizer, Vibr, Sentinel — not connected to Naro or AIOLSummary: DIL is a real, running local service (an Express/Node app on port 3100, backed by its own SQLite database) that Appnizer, Vibr, and Sentinel already call in production. Intention, as built today: a shared sink for cross-app policy, telemetry, and recommendations — narrower than the general "shared person/property/task context" role it's eventually meant to play.
This was verified directly against all four codebases (DIL itself, Appnizer, Vibr, Sentinel), not assumed from naming or documentation. All three integrations are already operationally integrated — participating in real production workflows, not scaffolding — though not load-bearing in the sense of being required: every call is wrapped to fail soft, and none of the three apps depends on DIL to function. What each app actually gets from it today:
- Appnizer — deployment-policy gating, a shared deployment/health-events sink, and a shared Knowledge store proxied through DIL.
- Vibr — shared recommendations surfaced in its Settings UI, a shared task-correlation record, and shared reusable preferences/agent profiles.
- Sentinel — shared project policy (verification/deployment/model-authority rules), advisory recommendations, and it reports task-execution outcomes and verification evidence back to DIL.
All three integrations are real production code (wired into main request/deploy paths, not scaffolding), and all three are explicitly best-effort: every call is wrapped to fail soft, so none of the three apps hard-depends on DIL to function.
What DIL does not yet have
DIL's own data model includes a real "ownership contract" concept (which app/artifact type is the writer vs. reader of a given record) and cross-project identity resolution (matching a project across Vibr/Sentinel/Appnizer) — but grepping DIL's entire codebase for dt_user_id or "DrezTek Identity" returns zero matches, and there is no formal, per-user access-grant model, only an audit log. So "DIL has prior design groundwork for namespaces, ownership, and access grants" is true for artifact-level ownership; it is not yet true for user-level, DrezTek-Identity-linked access control.
More importantly for this initiative: DIL's real API surface today is identity/timeline/policy/outcomes-shaped (/v1/projects, /v1/tasks, /v1/resolve-policy, /v1/recommendations) — there is no entity-resolution endpoint and nothing shaped like an AIOL Context Capsule. None of AIOL, "Context Capsule" (the AIOL sense), or "resolved intent" appear anywhere in DIL or its three consumers. (Sentinel and DIL's own recommendation engine each have an unrelated, internally-named "context capsule" concept — an LLM prompt-size budget, not the AIOL structure. Don't conflate the two.)
Naro itself has zero connection to DIL — confirmed directly, not merely absent from this document. Every Context Capsule Naro builds today is built entirely from Naro's own data.
What this means for next steps
The next question is not whether DIL should exist — it already does, and is already operationally integrated into three real applications' production workflows. The next question is whether its existing contracts can supply context to Naro, or be extended to produce an AIOL-conformant Context Capsule, without duplicating or restructuring systems that already work. The document does not assume DIL needs a new entity-resolution endpoint to do this — that's a plausible guess, stated as one, not a conclusion; whether it's true is exactly what a contract assessment would determine.
Two distinct pieces of work, not one, follow from this — conflating them earlier made the document read as if the audit both was and wasn't finished:
| Work | Status |
|---|---|
| Initial code inventory: which apps call DIL, the major endpoints/functions, that the integrations are production-path code, that they fail soft, DIL's current DB/service shape, that DrezTek Identity and AIOL are absent | Done — this session, summarized above |
| Deeper contract assessment: whether the three integrations share one stable interface, which capabilities Naro could actually reuse, and whether DIL should be extended to produce AIOL Context Capsules | Not started |
05 How a request actually flows
Every message passes through the same fork. Which side it lands on determines everything about cost, speed, and which processes are actually in effect.
Green = NRP + AIOL together (Flow A). Gray = the fallback, neither process in effect (Flow B).
Flow A — NRP + AIOL, most write requests
A message arrives at /chat or /chat/stream.
A deterministic handler recognizes the phrasing and extracts the request's arguments with a plain pattern match. No model call.
Looks up the user's real data and returns one of three outcomes: resolved, ambiguous, or none. Never guesses when more than one candidate matches.
An AIOL envelope is built from that outcome and validated against the schema — before anything is written. This is the one step that is AIOL, not NRP.
If validation fails, or the reference was ambiguous or not found, Naro replies with a plain refusal or clarifying question. Zero database writes either way, no model call to phrase it either.
If resolved and valid: the write executes, re-checking the record hasn't changed since step 3, then returns a short confirmation. Total model calls in this entire flow: zero.
Flow A' — the one live Context Capsule (also NRP + AIOL, but does call a model)
One route diverges from the zero-model-call shape above: "what should I work on next," which delivers an AIOL-validated Context Capsule folded into one user-turn for a single, small model call that turns a deterministically-ranked list into one sentence. NRP does the ranking; AIOL validates the capsule's structure before it's rendered; the model does only the wording. See Section 6 for what this measured.
This route is also the one live demonstration of NRP's middle "skill" tier (deterministic → skill → model): the ranking is produced by a real, versioned SkillManifest (suggest_next_task, v1.0.0), not an ad hoc function — confirmed directly in code, not left implicit. Every other live route today skips straight from a deterministic resolver to a write, with no skill in between.
Flow B — fallback, neither process in effect
Everything Flow A's handlers don't recognize — still the majority of what Naro can do — falls through to the original, un-optimized path: the message, available tool descriptions, and conversation context go to a real model, which decides which tool (if any) to call. No AIOL envelope is ever built or validated here, and none of NRP's resolvers run. This is the baseline every benchmark below compares against.
event.create/grocery.add, the model's exact tool-call proposal is what gets converted into an AIOL envelope, once a human confirms it unmodified (Section 3, Condition A). But "a model call and AIOL validation happen within one uninterrupted turn, with no human step in between" is not — that's only ever true for the one live Capsule route (Flow A'), where the model never sees or produces the AIOL structure itself; it only phrases a sentence from an already-validated capsule. And "the model directly emits a structured AIOL envelope" (Condition C) is not real anywhere yet. Read "GPT-4o-mini with AIOL" as referring to that narrowest, still-untested condition, not to the fact that a model and AIOL never coexist in the same conversation — they already do, via Condition A.06 Benchmarks
Two separate real measurements, each labeled by exactly which processes were actually in effect — read the labels before comparing numbers across tables.
"This initiative is efficient" would blur together at least three different effects: savings from NRP's deterministic-first routing, savings from Context Capsules' reduced payload, and whatever AIOL's own schema-validation step adds or costs on top of either. Both tables below keep these separate rather than reporting one blended number.
Benchmark 1 — write-safety intents (task.complete / task.reschedule), 10-case golden set
Runs today in naro/server/abp/scripts/task_capsule_golden_eval.py. A single local run, illustrative, not a controlled benchmark.
| Metric | Baseline — neither process | NRP alone | NRP + AIOL |
|---|---|---|---|
| Avg. latency | 4,483 ms | 7 ms | 13 ms |
| Avg. tokens (est.) | 26 | 12 | 15 |
| Correct outcomes | 6 / 10 | 10 / 10 | 6 / 6* |
| Wrong writes | 0 / 10 | 0 / 10 | 0 / 6* |
*The "NRP + AIOL" column only exercises the write-safety subset (6 of 10 cases) that's actually AIOL-validated live — see Section 3's coverage note.
Read honestly: essentially all of the latency and token reduction comes from the "NRP alone" column — deterministic routing avoiding a model call at all. The "NRP + AIOL" column's schema-validation step adds real, measurable overhead on top of that (roughly 6ms here) in exchange for a portable, validated result. AIOL's larger claimed advantage — one resolved meaning reused by a second application without it spending tokens to reinterpret the request — is exactly the part a single-implementation benchmark structurally cannot measure yet (Section 7).
Benchmark 2 — the live Context Capsule ("what should I work on next")
Added when this route went live. Real local model calls (Ollama, llama3.1:8b), fresh synthetic users each run — a cold-start measurement, not a warmed-prefix one.
| Metric | Baseline — full model tool loop | NRP + AIOL — live Capsule |
|---|---|---|
| Latency (the one case needing a model call) | 4.174 s | 2.685 s |
| Output size | 49 tokens | 23 tokens |
| Ranking source | Model judgment (unverified) | resolve_next_task — deterministic, code-guaranteed |
update_task happen); a read-only recommendation never triggers a write either way, so the harness always scores this case as a "failure" for the baseline regardless of actual quality. Reading the baseline's real text for this run ("Sunday, let's tackle that overdue bill first") shows it was in fact a correct recommendation. The defensible claim from this benchmark is narrower than "more correct": the NRP+AIOL path's ranking is code-guaranteed deterministic; the baseline's ranking was an unverified model judgment call that happened to be right this once. The latency and token gains above are real; the correctness gain is not proven by this benchmark.What isn't captured yet, honestly, in either table: separate routing/validation/execution timings, CPU/memory during parsing, 95th-percentile latency under load, per-request structured logging, or repeated trials with a median reported. Benchmark 2 specifically reports output tokens only — it does not yet measure Context Capsules' central resource claim, which is about the model's input payload. The next run of this benchmark should additionally capture: full-context input tokens, capsule-only input tokens, tool-schema tokens, total tokens, serialized context bytes, prompt-evaluation time separately from generation time, and both a cold-start and a warmed-prefix run — plus the exact conditions the numbers depend on (model: llama3.1:8b; Ollama version; quantization; CPU/GPU and memory; temperature; context window; whether structured-output mode was used). These are straightforward additions to the same harness whenever a benchmark needs to support a release-gate decision rather than a development-time sanity check — not done yet.
Read both tables as preliminary, not a general performance conclusion. Single local runs, rough token estimates, uneven case counts, no repeated trials. What they do support: deterministic-first routing produces a large, real advantage over a naive model tool-calling loop, and AIOL's own validation cost on top of that is small and measurable. Establishing a general conclusion would mean running every path against the same applicable cases, repeating the run, and reporting median and p95 — not yet done.
07 Verification & conformance
What's actually run, on every change, not asserted in prose.
AIOL's own specification repository (36 tests) checks every schema is well-formed and that every example fixture — valid and deliberately invalid — validates the way its description claims. Naro's backend suite (482 tests as of this initiative's most recent work) goes further: it validates real function output against these schemas, not hand-written examples, and proves specific safety properties directly:
- Nine independently-phrased real requests ("Mark water the plants done," "I finished watering the plants," …) all extract the same canonical intent and arguments.
- A validation failure on any guarded write results in zero database calls — proven by injecting a broken envelope and asserting the underlying write function was never invoked.
- Naro's own vendored schema copy is checked byte-for-byte against the AIOL repository's authoritative source, so the two can never silently drift apart.
- A frozen 10-case golden request set gates every change: zero wrong-writes and 100% correct resolution required before a change is considered non-regressive.
| Provable now, one implementation | Blocked until a second exists | |
|---|---|---|
| Correctness | Schema-valid envelopes from real output; equivalent phrasings normalize to the same canonical intent; invalid envelopes rejected with zero writes | — |
| Interoperability | — | Whether two applications reach the same operational meaning from the same envelope with no re-interpretation; whether different models produce equivalent AIOL for the same request |
| Transport | — | Whether meaning survives unchanged through MCP, A2A, or any other binding |
08 Status & roadmap
NRP is Naro-specific and partially live; AIOL is 0.1, experimental, with Naro as its only reference implementation; DIL is real and running, already used by three other DrezTek apps, but not yet connected to Naro or AIOL. None of the three makes a cross-application AIOL interoperability claim yet.
| Step | Process | Status |
|---|---|---|
| Deterministic resolvers for 6 intents | NRP | Done |
Deterministic Resolution Ladder shortcuts for event.create/grocery.add's plain, common phrasing (Phase 13) — both still end in the existing confirm-then-validate gate, unchanged | NRP | Done |
| An escalation option ("Something else") on every confirm card, so a wrong/incomplete proposal can be sent back to the model for clarification instead of only Confirm/Cancel (Phase 14) — frontend-only, reuses the existing chat pipeline, no new backend/AIOL surface | NRP | Done |
| Deterministic escalation alternatives (surface candidates directly, no model call) on the same button, as a later refinement | NRP | Not started |
| Core envelope + Tasks/Calendar/Grocery/Context vocabularies | AIOL | Done |
| Validate-before-write gate, complete on all 6 intents (Section 3) | AIOL | Done |
AIOL-gate all three Tasks intents' model-tool-loop proposals (task.create, task.complete, task.reschedule — Phase 15, one shared interception point around update_task/create_task, extending Condition A's already-proven confirm-gate pattern rather than a separate no-confirm design) | AIOL | Done |
| One live, read-only Context Capsule (also the first live demonstration of the Ladder's skill tier) | NRP + AIOL | Done |
| Measure the live Capsule against the baseline (output tokens, latency) | NRP + AIOL | Done (Section 6, Benchmark 2) |
| Expand that measurement to full input-token accounting and fixed run conditions | NRP + AIOL | Open |
| Initial code inventory of the 3 existing DIL integrations (Appnizer/Vibr/Sentinel) | DIL | Done, this session (Section 4) — a narrow code audit, not a design |
| Deeper contract assessment: one stable interface or three independent ones? What can Naro reuse? | DIL | Not started |
| DIL capability to supply an AIOL-conformant Context Capsule | DIL + AIOL | Not started — whether DIL needs a new endpoint for this is exactly what the contract assessment above would determine, not assumed here |
| Cross-application proof: a second app consuming a real AIOL envelope | AIOL | Not started |
| Model semantic interoperability — do different models produce equivalent AIOL envelopes for the same request? | AIOL | Not started |
| Model and context efficiency evaluation — compare small local / larger local / inexpensive API / capable API models across full-context vs. Capsule, and deterministic vs. model routing, on latency/tokens/cost/accuracy/clarification behavior | NRP + AIOL | Not started — distinct from the model-interoperability item above; both are needed, neither replaces the other |
| Transport bindings (MCP, A2A) | AIOL | Not started |
| Public 0.x release (repo, docs site, schema downloads) | AIOL | Not started |
| Three deterministic views (Today/Week/Upcoming) over Tasks/Events, exposed as model tools plus a Developer Console inspector | LIV | Done |
| Zero-model-call counting fast path extended from Today-scoped questions to Week-scoped ones (due this week, unscheduled, events this week) | LIV | Done, this session (Section 9) |
| Developer Console label clarifying JSON mode shows the full computation, not literally what the model receives — only Rendered mode is byte-for-byte identical to it | LIV | Done, this session (Section 9) |
| Split into a shared data layer (LID) with purpose-built views (LIV) on top | LIV | Not started — no second view yet needs to share one underlying computation (Section 9) |
| Extend the same pre-computation pattern to other domains (Finance, Home, Relationships, Business) | LIV | Not started — no evidenced domain need yet (Section 9) |
| Register Naro's views with DIL so other DrezTek apps can discover them without knowing Naro's schema | LIV + DIL | Not started — blocked on DIL having no schema-agnostic discovery endpoint yet (Section 4, Section 9) |
09 Live Intelligence Views — the pre-computed data layer under NRP's zero-model reads
Deterministic, always-current views of Tasks and Events that let both the Resolution Ladder and the model itself skip raw-row discovery. Real, shipped infrastructure the other processes build on — not a fourth peer process, and not evaluated as a per-module completion criterion the way NRP/Capsule/Guarded-Execution/DIL are (Section 1).
Live Intelligence Views
Live for Tasks/Events — not extended to other domains, not registered with DILSummary: three views — Today, Week, Upcoming — computed live from Naro's own Tasks/Events data and hand the model (or the Ladder's zero-model fast path) an already-organized, token-bounded answer instead of raw rows it would otherwise have to search and calculate over itself. Intention: don't make the model smarter — make the environment around it smarter, so a small or local model reasons over a few hundred already-correct tokens instead of rediscovering the same facts itself.
The name is already in shipped code and UI, not coined for this document: naro_live_views_api.py's own docstring, liveViewsService.ts's doc comment, and the Developer Console's section title all say "Live Intelligence Views" verbatim. "LID" (Live Intelligence Data, naming a future data-layer/view split — see below) is planning terminology only; no such concept exists in the codebase today.
Live today
compute_today_view/compute_week_view/compute_upcoming_view(naro_live_views_service.py) — due/overdue/completed tasks, timed and all-day events, schedule-conflict pairs, open time blocks, and a rendered plain-language summary. Computed fresh on every read, no cache — no measured cost yet to justify one.- Exposed to the model as three tool-calling functions, each trimmed to just the rendered summary before being sent — a measured 686 tokens full vs. 116 trimmed on the Week view.
- A zero-model fast path answers simple counting questions directly from these views, no model call at all: originally Today-scoped only (due today, overdue, completed today, events today); extended this session to Week-scoped counts too (due this week, unscheduled, events this week), reusing
compute_week_viewunmodified. - Already reused as shared infrastructure, not duplicated: the Resolution Ladder's due-today task resolver wraps
compute_today_viewrather than re-querying tasks directly, and event-creation's schedule-conflict warning reuses the same overlap-detection logic. - A Developer Console inspector shows Rendered mode (byte-for-byte what the model receives) and JSON mode (the fuller computation behind it) — clarified this session that only Rendered is literally "what the model saw"; JSON shows strictly more, since the actual tool result is trimmed down before it ever reaches the model.
Real value, once there's evidence to act on
Three ideas from the original design discussion have genuine future value but no evidenced need yet. Building any of them now would mean designing ahead of proof, which this initiative has deliberately avoided at every other step (e.g. Context Capsule wasn't extracted into its own module until both Tasks and Journal actually needed it).
| Idea | Why it's real, and why not yet |
|---|---|
| Split into a shared data layer (LID) with purpose-built views (LIV) drawn from it | Valuable once two views genuinely need to share one underlying computation. Not yet true anywhere — every view today goes straight from query to shaped output in one step, with nothing to share. |
| Extend the same pattern to other domains (Finance, Home, Relationships, Business) | Real, scoped feature work per domain — each needs its own definition of what's worth pre-computing (a finance "anomaly," a business job "requiring attention"). Worth building where there's evidence the model currently reasons poorly, or spends unnecessary tokens, over that domain's raw data. No such domain has been identified yet. |
| Register these views with DIL so other DrezTek apps (Vibr, Sentinel, Appnizer) can discover them without knowing Naro's schema | The most strategically valuable idea here, but genuinely blocked rather than merely deprioritized: DIL has no schema-agnostic discovery endpoint today, and Naro has zero connection to DIL at all (Section 4). Building Naro's half now would produce a registration hook with nothing on the other end to consume it. |
Watching, not building
A general relevance router that decides which view type a request needs only becomes necessary once there are enough view types for a request to be genuinely ambiguous between them. With three views today, all in one domain, ordinary model tool-calling already picks correctly — there is nothing yet for a router to do that isn't already handled. Revisit if and when multi-domain views (above) actually ship.
Nothing here was found to have no value
Every idea considered above — the LID/LIV split, per-domain expansion, DIL registration, and a general router — carries real, if conditional, future value. None was eliminated as worthless now or later; what separates "build it," "wait for evidence," and "watch" is evidence and dependency ordering, not merit.
10 Who this is for
- Developers. NRP is Naro-specific and not meant to be adopted elsewhere as-is. AIOL is the portable part — its schemas are static JSON files, vendor them locally, no network dependency, no account. Start with dreztek/aiol's optional compatibility fields; they're the cheapest way to gain interoperability with anything AIOL-aware.
- Investors and interested entities. Preliminary measurements from one working, tested reference implementation (Section 6) show a real advantage from deterministic-first routing over naive model-tool-calling, and a small, measurable validation cost from AIOL on top of it — not yet a controlled, general performance conclusion, and no cross-application proof exists yet either. Both gaps are stated plainly here, not implied away.
- Agents and models. Most of a conversation with Naro still never involves AIOL at all — only six intents currently route through it, and only one of those makes a model call in the first place. Where AIOL is involved: propose an interpretation, never assume it's final; a validation failure must not execute; expect a structured refusal or clarifying question when a reference is ambiguous.