Jev and the coding-agent harness: decisions, context, cost and control
A technical survey of typed decision models and reliable agent runtimes, with a critical reading of the circulating Jev PDF, original architecture and an executable local harness.
Sources & version details
In this article
What Jev changes—and what it leaves to your software
A coding agent is a stateful program that alternates inference with actions. Its harness is the runtime around the model: assembling context, exposing tools, enforcing budgets, recording observations and deciding when execution may proceed. A model can propose a patch; the harness determines which repository snapshot it sees and what authority that patch receives. These are separate responsibilities.
Jev is TypeSafe’s decision model, not a replacement code generator. Its interface produces typed judgments from supplied state [1]. Imagine an SRE agent fixing retry amplification in an HTTP client: one model writes the change, while a bounded decision service helps choose relevant evidence or a specialist. The software still authenticates the caller, loads the files, applies policy and verifies the result.
By the end, you should be able to separate decision quality from execution safety, calculate whether routing saves money, build a small replayable harness, and design a credible comparison. You need to understand JSON as a data contract, probability as uncertainty over outcomes, and caching as reuse conditional on an exact identity. Familiarity with Python functions and request timeouts is enough for the local exercise; no hosted model is required.
Read the viral claim at the right level
The circulating twelve-page PDF labels itself an independent September 2026 synthesis, not endorsed by TypeSafe. It proposes explicit state, query-aware context and policy-controlled routing [2]. Diogo Almeida is an InstructGPT coauthor [3]; that fact does not establish that he authored this PDF.
TypeSafe’s launch report attributes 193.6× speed and 444.6× cost ratios to selected System One workflows, using model-reference probabilities rather than human ground-truth correctness [4]. Those figures do not establish a coding-agent speedup. The “two-hour setup” claim in the supplied post has no reproducible installation-and-outcome protocol attached.
A decision call, a workflow, and a completed software change have different denominators. A fast classification can coexist with a slow test suite. A cheaper attempt can become more expensive per correct fix if it causes retries. Treat the post as a lead to investigate, not as a deployment specification. This article provides original engineering analysis and a local simulation, not a reconstruction of undisclosed Jev internals.
From generated sentences to bounded decisions
An autoregressive generator repeatedly predicts the next token conditioned on its prefix. A decision task instead asks for a distribution over an already specified set. TypeSafe describes parallel decision outputs and calls its training approach RLCD [4] [5]. The reviewed material does not disclose enough architecture, loss, data and optimizer detail to reproduce Jev training; do not replace those unknowns with a guessed softmax head or invented reinforcement-learning equation.
For the retry incident, asking “fix this service” requires investigation and synthesis. Asking “which subsystem should receive this evidence packet?” is bounded by a candidate list. The latter can fit a decision interface. The critical engineering work is deciding what evidence the interface gets: a stack trace without the retry policy can make an accurate-looking classification irrelevant to the real cause.
A constrained output prevents an out-of-schema tool name; it cannot prevent choosing the wrong valid tool. The analogy is a typed function returning the wrong integer: the type checker proves a structural property, not the business conclusion. A probability model and a JSON-constrained LLM can both produce valid objects. Their latency, calibration and quality must be compared on the same decision task, not inferred from interface aesthetics.
In the notation, x is the input, y₁:T is the generated token sequence, s is application state, Q is the typed question and A is the permitted answer set. The second expression is an interface abstraction, not a disclosed Jev training objective.
Design the question before selecting the model
Choice selects from named alternatives; Score represents ordered rubric levels; Noul returns the probability of a yes/no proposition [6] [7] [8]. Keep those contracts distinct. A relevance score of 0.8 is not automatically an 80% probability that a patch is correct. A choice among three subsystems is not evidence that any of them actually contains the bug.
Our evidence packet contains a goal, repository revision, failing assertion, bounded file excerpts, allowed candidate IDs and a statement of missing evidence. Ask separately whether the available evidence is sufficient and which candidate is most relevant. A low sufficiency answer requests more evidence; it must not silently become “choose the most plausible anyway.” Missing data and contradictory data deserve different recorded reasons.
Batch independent questions over one snapshot: relevance, ownership and missing evidence. If question B depends on A’s answer, compose them in code and make a second stage. Calling them together does not create a conditional reasoning chain. Keep thresholds and prompt versions in configuration so a changed rubric creates a new decision version, rather than silently changing the meaning of old logs.
Calibration, concentration and the cost of being wrong
TypeSafe’s Choice confidence rescales the largest probability relative to a uniform distribution [9]. With three options and top probability 0.8, confidence is 0.7. These two numbers are derived from the same output; checking both is not two independent confirmations. Noul has its own probability and no separate confidence field.
Calibration is a population property: among predictions near 0.8, the event should occur about 80% of the time. A well-calibrated classifier can still make many mistakes; an always-base-rate predictor can be calibrated and useless for ranking. Conversely, a high-accuracy classifier can be dangerously overconfident on the rare incidents where an action is costly. Evaluate slices such as repository, language and action class, and watch distribution shifts after a model or rubric change.
Our decision-theory example assumes a wrong action loses 100 utility units while manual review costs 2 and resolves the case perfectly. Automatic action has expected loss (1−p)×100; it beats review only when p>0.98. This is a teaching calculation, not a production threshold. Review can be wrong, losses differ by action, and predicted p needs local validation. A probability estimate never grants permission.
A reference architecture for the retry incident
The controller first creates a task ID, checks the caller’s repository scope and freezes a commit. A reader obtains permitted files and attaches source paths, ranges and hashes. Secrets are filtered before any external decision request; the cheap router is an external recipient too. The state store holds immutable observations, while the controller owns the current task status. Neither model can directly rewrite policy.
The context builder pins mandatory instructions and the failing assertion, then adds relevant evidence within a token budget. A decision adapter proposes a route; a policy filter intersects that recommendation with eligible providers and remaining budget. The generator receives the selected packet and returns a patch proposal. The executor checks the exact patch and task scope before applying it to an isolated worktree. Execution observations re-enter state as data, never as new authority.
Every edge has a failure behavior. Timeout in the decision adapter selects the existing conservative route or asks for review. Malformed responses cannot execute tools. An expired snapshot triggers reread. A cancelled task cannot launch new actions, although an already-dispatched external request may still cost money. Audit persistence must precede privileged dispatch; after a crash, reconcile unknown outcomes rather than blindly retrying writes.
| Component | Input → output | What it cannot establish |
|---|---|---|
| Decision model | Evidence + candidates → probabilities | Permission or factual certainty |
| Context builder | Allowed chunks + budget → packet | That omitted evidence is irrelevant |
| Policy engine | Identity + action + scope → allow/review/deny | That an allowed patch is correct |
| Executor | Authorized proposal → observation | That a timeout means no side effect |
| Independent verifier | Patch + fixed checks → outcome | General correctness beyond coverage |
Context selection is a budgeted evidence problem
For our retry repair, a pinned “never remove the retry cap” invariant, the current implementation and the failing assertion are more important than an attractive summary of last week’s discussion. A chunk therefore needs more than text: ID, revision, provenance, visibility label, estimated token size, access scope and whether it is mandatory. Summary text should retain a link to the original; a summary is not the canonical source.
The teaching optimization below chooses one representation v for each chunk i, maximizing utility under budget B. Utilities are estimates, not truth; adding pairwise dependencies makes the problem harder. A definition and its caller may each look weak separately but be essential together. Pin critical contracts first, reserve output budget, and refuse a budget that cannot fit mandatory evidence. Never silently drop a policy to satisfy a token limit.
A stable policy prefix can preserve reuse, but dynamically reordering all evidence every turn can destroy it. Keep separately versioned stable and task-specific regions. Record which source hashes supported a decision, and invalidate derived summaries on source change. Repository search can itself be a bottleneck: FastContext studies this separately from Jev [10]; its results must not be relabeled as Jev measurements.
Cost the whole route, not just the cheap call
Our synthetic price model uses uncached input, cached input, output and decision-service charges separately. For one hypothetical step, 10,000 uncached input tokens at $2 per million plus 1,000 output tokens at $8 per million costs $0.028. These are invented prices for arithmetic, not current provider quotes. A cheap route that costs $0.010 but adds $0.015 of transfer/review work and $0.001 of routing totals $0.026: only 7.1% cheaper. Add $0.004 of expected retries and it loses.
Amdahl’s law gives another bound. Suppose decision calls occupy 20% of elapsed time and become 200× faster; with all else unchanged the whole task improves only 1/(0.8+0.2/200), about 1.248×. If code generation, CI and approval dominate, this is the relevant intuition. Parallel calls need a critical-path calculation instead of adding every span; overlapping work is not free capacity.
Compare cost per accepted fix, not only cost per API call. Divide total cost—including failures, review, retrieval and infrastructure—by the number of accepted fixes under a fixed correctness criterion. Match repository snapshots, task difficulty and cache conditions. Prompt caching and GPU KV residency are related optimizations but not identical billing contracts; cross-model reuse must not be assumed.
Here nᵤ, n꜀ and nₒ count uncached input, cached input and output tokens; pᵤ, p꜀ and pₒ are dollars per million of each. C_d is the decision charge. In S, f is the original elapsed-time fraction improved and s its speed multiplier; the formula assumes a serial decomposition and unchanged other work.
A recommendation is never an execution capability
In the retry scenario the allowed task is to prepare a patch, not deploy it. An apparently excellent decision to restart production is still outside scope. Enforce permitted actions and targets before model routing and again immediately before dispatch. The second check prevents a stale approval from authorizing a changed patch. Bind approval to task ID, action digest, target, expiry and repository revision.
Do not secure a shell by scanning for a few dangerous strings. Quoting, subprocesses, imported modules and symlinks defeat superficial checks. Prefer narrow typed operations, canonical paths, a sandbox without ambient production credentials, controlled network egress and resource limits. Even a command called “test” executes repository code. An independent classifier can flag suspicious intent; it cannot prove arbitrary script safety.
Prompt injection can enter through source comments, logs and search results. Label provenance and keep instructions separate from retrieved text. A confidence of 1.0 in “ignore the policy” remains unauthorized. If a write times out, the remote side may already have applied it. Use operation IDs and status reconciliation where supported; a local SQLite transaction cannot make an external API and your audit database atomic.
Integrate one decision point before rebuilding the agent
There are three different integration depths. A skill supplies implementation guidance. A callable tool exposes a decision service to an existing agent. A native harness controls every context packet, state transition and permission boundary. Installing a skill does not confer the third capability. Verify the extension surface of your actual agent version before promising automatic per-turn interception.
Start with read-only evidence ranking. Save the old ranking and the proposed ranking without changing execution. Review disagreement cases, then enable the new ranking for a small task cohort with an immediate fallback switch. Keep the original path available. Later introduce model routing only when the evidence packet can be passed independently and the return result is compact and attributable.
A production adapter must validate response schema, record the resolved model version, set deadlines, cap concurrency and count failed attempts. Do not retry indefinitely on rate limits. Cache decisions by model version, question version, policy version and state hash; do not reuse cross-tenant results. The official API entry point and skill are linked at the end [11] [12]. This website makes no paid calls; the included lab substitutes explicit fixtures, and the API request example is documentation, not an executed integration.
When the pattern pays—and where it breaks
For deterministic facts, ordinary code wins: checking an allowlist or exact schema does not need a model. For broad semantic ranking, embeddings or a reranker may be simpler. For a bounded judgment with rich context, a specialized decision model is a candidate. For constructing a novel algorithm or patch, keep a generative model. These components can coexist without making every branch an AI call.
The buyer is often a developer-platform or agent-infrastructure team. What matters commercially is successful task throughput at a quality and privacy target. A specialized provider can compete on latency, calibration and integration quality; a general-model vendor can bundle routing and exploit cache locality. A harness vendor controls workflow and audit, while a self-hosted classifier controls data location but creates training and operations work. This is a control-point analysis, not a market-share ranking; no unverified financing or acquisitions are implied.
Open problems include rare-event calibration, detecting missing candidates, preserving dependencies during context pruning, correlated mistakes across judges, and measuring savings after human review. Closed model internals limit independent mechanism attribution. Faster decisions can also encourage excessive parallel work and larger bills. A bounded router is useful engineering; it is not evidence that an agent recursively improves its own intelligence.
Practice, validation and interview preparation
Run with Python 3.11 or later: python3 lab.py. There are no dependencies, credentials or network requests. The fixture is deterministic, so no random seed is needed. SQLite runs in memory; five distinct decisions remain after an identical request is replayed. This demonstrates request identity, not durable recovery across process restarts.
Trace the control flow: mandatory evidence is selected first; a validated probability distribution proposes a route; policy can deny the action regardless of that distribution; a hashed input identifies replay. The greedy selector is intentionally simple and not globally optimal. Estimated token counts are fixture inputs, not real tokenizer measurements. No tool command is executed and no patch is generated.
The output should select policy/assertion/implementation, reject a too-small evidence budget, route low-confidence and malformed answers to review, deny deployment, and create a new record when the revision changes. Then inject an unapproved provider, a NaN probability, a missing candidate and a changed policy version. Expected outcomes: review, schema rejection, schema rejection, and a new decision identity. Add a concurrent-writer test before replacing the in-memory demonstration with durable storage.
For a real comparison, fix repositories and held-out tasks before tuning. Compare the unchanged agent, deterministic heuristics, a structured-output LLM and Jev with identical allowed tools. Add context selection and routing separately. Record task success, cost per accepted fix, p50/p95 latency, cache hit rate, human-review time and policy violations. Stratify by difficulty, repeat runs, report uncertainty and keep failed runs. Use a calibration split to choose thresholds and a separate test split for the final result.
For probabilities, compute the binary Brier score, the mean of (p−y)², and reliability bins; the toy values produce 0.255. A four-case example does not establish calibration. Check selective coverage and error rate as the threshold rises: a system that sends everything to humans can look accurate but automate nothing. Evaluation should also include missing evidence, injected instructions, outages, stale hashes and ambiguous write completion.
Download the complete local Python lab"""Python 3.11+, standard library only. Offline harness simulation, NOT Jev.
No network, shell execution, real code edits, GPU or model benchmark.
Run: python3 lab.py
"""
from dataclasses import dataclass
from hashlib import sha256
import json
import math
import sqlite3
@dataclass(frozen=True)
class Chunk:
id: str
revision: str
text: str
tokens: int # Synthetic fixture sizes, not a tokenizer measurement.
utility: float
mandatory: bool = False
def select(chunks, budget):
if budget < 0 or len({c.id for c in chunks}) != len(chunks):
raise ValueError("invalid budget or duplicate chunk")
if any(c.tokens <= 0 or not math.isfinite(c.utility) for c in chunks):
raise ValueError("invalid chunk")
pinned = [c for c in chunks if c.mandatory]
left = budget - sum(c.tokens for c in pinned)
if left < 0:
raise ValueError("mandatory evidence exceeds budget")
result = pinned[:]
# A transparent greedy heuristic; not an optimal dependency-aware solver.
for c in sorted((c for c in chunks if not c.mandatory),
key=lambda c: (-c.utility / c.tokens, c.id)):
if c.tokens <= left:
result.append(c)
left -= c.tokens
return result
def validate_answer(answer):
if not isinstance(answer, dict) or set(answer) != {"choice", "probabilities"}:
raise ValueError("invalid answer schema")
p = answer["probabilities"]
if not isinstance(p, dict) or set(p) != {"local", "frontier", "review"}:
raise ValueError("unknown candidates")
if any(type(x) not in (int, float) or not math.isfinite(x) or not 0 <= x <= 1
for x in p.values()) or not math.isclose(sum(p.values()), 1.0, abs_tol=1e-8):
raise ValueError("invalid probabilities")
if answer["choice"] not in p or p[answer["choice"]] != max(p.values()):
raise ValueError("choice does not match maximum")
return p
def choose_route(answer, action, policy):
# These are typed fixture actions. No shell-string safety claims.
if action not in policy["allowed_actions"]:
return "deny"
try:
p = validate_answer(answer)
except ValueError:
return "review"
target = answer["choice"]
if target not in policy["eligible_routes"] or p[target] < policy["threshold"]:
return "review"
return target
def record(db, state, action, policy, answer):
# Identity includes all decision inputs, not just an action name.
payload = json.dumps([state, action, policy, answer], sort_keys=True,
separators=(",", ":"), allow_nan=False)
key = sha256(payload.encode()).hexdigest()
existing = db.execute("SELECT result FROM events WHERE id=?", (key,)).fetchone()
if existing:
return existing[0], True
result = choose_route(answer, action, policy)
with db:
db.execute("INSERT INTO events VALUES (?, ?, ?)", (key, payload, result))
return result, False
def run():
policy = {"version": "policy-1", "allowed_actions": ["inspect", "propose_patch"],
"eligible_routes": ["local", "frontier", "review"], "threshold": 0.9}
chunks = [Chunk("policy", "r1", "Keep retry cap; do not deploy.", 40, 1, True),
Chunk("assertion", "r1", "Expected at most three attempts.", 60, 1, True),
Chunk("implementation", "r1", "Current retry loop.", 120, 0.96),
Chunk("old_chat", "r0", "Superseded discussion.", 400, 0.1)]
chosen = select(chunks, 240)
assert [x.id for x in chosen] == ["policy", "assertion", "implementation"]
try:
select(chunks, 99)
except ValueError:
pass
else:
raise AssertionError("must reject missing mandatory evidence")
state = {"task": "retry-incident", "revision": "r1", "question_version": "q1",
"chunks": [c.__dict__ for c in chosen]}
good = {"choice": "local", "probabilities": {"local": 0.94, "frontier": 0.04, "review": 0.02}}
low = {"choice": "local", "probabilities": {"local": 0.55, "frontier": 0.4, "review": 0.05}}
malformed = {"choice": "delete_production", "probabilities": {"other": 1.0}}
# In-memory SQLite tests replay logic without leaving personal data behind.
with sqlite3.connect(":memory:") as db:
db.execute("CREATE TABLE events (id TEXT PRIMARY KEY, payload TEXT, result TEXT)")
assert record(db, state, "inspect", policy, good) == ("local", False)
assert record(db, state, "inspect", policy, good) == ("local", True)
assert record(db, state, "inspect", policy, low)[0] == "review"
assert record(db, state, "inspect", policy, malformed)[0] == "review"
assert record(db, state, "deploy", policy, good)[0] == "deny"
changed = dict(state, revision="r2")
assert record(db, changed, "inspect", policy, good) == ("local", False)
count = db.execute("SELECT COUNT(*) FROM events").fetchone()[0]
assert count == 5
n, p = 3, 0.8
confidence = (p - 1/n) / (1 - 1/n)
speedup = 1 / (0.8 + 0.2/200)
assert math.isclose(confidence, 0.7)
# Synthetic binary forecasts; Brier is not measured on Jev.
forecasts, outcomes = [0.9, 0.8, 0.4, 0.1], [1, 0, 1, 0]
brier = sum((p-y)**2 for p, y in zip(forecasts, outcomes)) / len(outcomes)
print(json.dumps({"mode": "offline_fixture_not_jev", "network_calls": 0,
"selected_chunks": [x.id for x in chosen], "audit_rows": count,
"choice_confidence": round(confidence, 6),
"synthetic_task_speedup": round(speedup, 6),
"synthetic_brier": round(brier, 6),
"replay_schema_policy_revision_checks": "passed"}, indent=2))
if __name__ == "__main__":
run()
Expected output
{
"mode": "offline_fixture_not_jev",
"network_calls": 0,
"selected_chunks": [
"policy",
"assertion",
"implementation"
],
"audit_rows": 5,
"choice_confidence": 0.7,
"synthetic_task_speedup": 1.248439,
"synthetic_brier": 0.255,
"replay_schema_policy_revision_checks": "passed"
}
Optional integration contract—not executed
The JSON below is an illustrative request body for the official POST https://api.typesafe.ai/v1/systemone contract checked on the source-review date. It is not sent here. Use the official authentication guide and a private server-side credential; never embed a key in this static site. Resolve and record the actual model version behind jev-latest, retain a lockfile if using an SDK, and validate responses. This article does not claim a verified live API run.
{
"model": "jev-latest",
"state": {
"goal": "Identify evidence for a retry amplification incident",
"revision": "example-r1",
"evidence": "Fixture: retry loop restarts its attempt counter after a timeout; required cap is three attempts."
},
"questions": {
"subsystem": {
"type": "choice",
"instructions": "Which subsystem is directly implicated by the supplied evidence?",
"criteria": {
"retry_control": "Attempt counting, stopping and retry budget",
"rendering": "Displaying a user interface",
"unknown": "The supplied evidence does not identify a subsystem"
}
}
}
}
Original interview questions—not reported company questions
1. Why is 200× per decision not 200× per task?
Hint: identify the unchanged critical path. Answer: with
2. Can confidence 0.99 authorize deployment?
Hint: distinguish belief and authority. Answer: no. Check probability semantics, but authorization still requires scope, target, approval and a current action digest.
3. When can cheaper model routing cost more?
Hint: account for both handoffs. Answer: context reload, review, lost cache and failures can exceed generation savings; compare dollars per accepted fix with matched tasks.
4. How do you distinguish useful calibration from avoiding all work?
Hint: measure coverage with risk. Answer: report error among automatic actions and automatic coverage together, plus review cost; use held-out outcomes and include rare high-impact slices.
Scoring: 1—repeat terminology; 2—separate model and harness; 3—implement the fixture and explain cost/confidence; 4—handle versioning, failure and authorization; 5—design a fair task-level comparison and defend its limits.
Continue learning
Foundations explained
Review the shared reasoning behind this method, then use the worked checks to identify gaps in your understanding.
An agent is a stateful control loop: observe, propose an action, check permission, execute, and inspect the result. A tool schema only describes valid arguments; it does not prove the caller is authorized or the requested side effect occurred. Model-generated text is therefore a proposal, not trusted execution evidence. You should distinguish an attempted call, a successful response and a verified task outcome.
Work it out before reading the solution
A payment tool times out after receiving a request. Should an agent immediately retry because it has no success response?
Reasoning, step by step
No. A timeout leaves the outcome unknown: payment may have succeeded before the reply was lost. Use an idempotency key and a status check, or pause for reconciliation. Blind retries can duplicate an irreversible action. A step limit bounds attempts but cannot repair this correctness error.
Why this matters in practice
This is why tool-using assistants need application-level memory, authorization and stop conditions. State must record what is known, what is uncertain and what still requires confirmation. More autonomy is useful only when completion can be verified and action scope remains controlled.
Evidence of understanding
Trace success, rejection, timeout and malformed response through the same workflow. Assert that denied actions never execute and that retries preserve idempotency. Separately cap steps, time and spend. Test these properties with a mock tool locally before considering real side effects.
Run the complete Python example
Python 3.10+ · standard library only · deterministic, no random seed needed · no network. Save the file and run the command below. These are teaching checks, not model benchmarks.
Download Python · agent.pypython3 agent.py# Python 3.10+; standard library; deterministic; no network.
# In-memory mock only: no real payment or network call.
ledger = {}
def pay(key, amount):
if key in ledger:
if ledger[key] != amount:
raise ValueError("same key with different request")
return "already applied"
ledger[key] = amount
return "applied"
assert pay("order-1", 10) == "applied"
# Pretend the reply was lost. Reconcile and retry with the same key.
assert ledger.get("order-1") == 10
assert pay("order-1", 10) == "already applied"
assert len(ledger) == 1
try:
pay("order-1", 20)
raise AssertionError("conflicting retry accepted")
except ValueError:
pass
print("one effect; duplicate retry suppressed")
Expected output
one effect; duplicate retry suppressed
Foundation revised:
References and further tutorials
- TypeSafe — Introductionhttps://docs.typesafe.ai/introduction
- Jev Engineering for Coding Agents — PDF · 2026-09https://jevforagents.com/media/Jev-Engineering-for-Coding-Agents.pdf
- InstructGPT — arXiv:2203.02155v1 · 2022-03-04https://arxiv.org/abs/2203.02155v1
- TypeSafe — Introducing System One Models & Jev · 2026-09-15https://typesafe.ai/blog/introducing-system-one-models-and-jev
- TypeSafe — AI primer / RLCDhttps://docs.typesafe.ai/introduction/machine-learning-primer
- TypeSafe — Choicehttps://docs.typesafe.ai/primitives/choice
- TypeSafe — Scorehttps://docs.typesafe.ai/primitives/score
- TypeSafe — Noulhttps://docs.typesafe.ai/primitives/noul
- TypeSafe — Confidencehttps://docs.typesafe.ai/confidence
- FastContext — arXiv HTML v1https://arxiv.org/html/2606.14066v1
- TypeSafe — API / Quick starthttps://docs.typesafe.ai/introduction/quickstart
- TypeSafe — Agent skillshttps://github.com/typesafe-ai/skills
- TypeSafe — Workflow evaluationshttps://evals.typesafe.ai/
- InstructGPT — PDF v1https://arxiv.org/pdf/2203.02155v1
- FastContext — abstract / version historyhttps://arxiv.org/abs/2606.14066v1
- FastContext — PDF v1https://arxiv.org/pdf/2606.14066v1