Scope drift
An edit lands too broadly, or in the wrong place entirely. Nothing at the generation layer binds a task to the region it was allowed to touch.
AI Infrastructure · Write-path control plane
Control the change.
Prove the result.
Reuse the work.
Datafew is the control plane between coding agents and your repository. It authorizes what an agent may change, gates every write, verifies by real execution, and lets only work that passed become reusable.
Model-agnostic and assistant-agnostic. Datafew sits underneath the agents you already use — it does not replace them, and it does not train models.
The gap
Generation is probabilistic. Admission should not be.
Every coding agent on the market is an LLM at its core: a probabilistic predictor, not a deterministic program. The same task yields different output across runs, and “almost right, but not quite” is the norm rather than an occasional defect. What is missing is not another assistant. It is a deterministic layer between generation and the repository.
Structural decay
Each accepted change makes the next one harder to reason about. Repository structure degrades in a direction no single diff review catches.
After-the-fact review
Teams are left inspecting, testing, and scanning writes that already happened — trust cost and wasted tokens rising together.
How it works
A gate at every step of the agent’s loop
Datafew is a runtime layer that wraps the agent’s entire working loop — planning, writing, observing, and iterating all run inside it. It is not a checkpoint in the middle of a pipeline, and not an output checker at the end. The only thing that leaves the layer and reaches the repository is an admitted write.
-
01
Plan
Scope gate
The editable range is bound at task start. Everything outside it is locked.
-
02
Write
Admission gate
Nothing lands without passing. A rejected write is repaired under constraint, inside the authorized block.
-
03
Observe
Verification
Judged by real execution, not by a model’s opinion of its own output. Evidence is recorded.
-
04
Iterate
Reuse gate
Only results that passed the gates qualify for the reuse path. The loop returns to Plan.
First-party results
Measured on a public benchmark, judged by real execution
All 128 runnable tasks of BigCodeBench-Hard, the same model, the same per-call generation settings. Code counts as passing only if it actually runs and passes real Python unittest execution.
32% → 89%
Pass rate of the same model
41/128 raw · 114/128 with the control plane
73 : 0
Control-plane-only passes : raw-only passes
Strictly one-sided — no task regresses
2.89×
Total tokens spent by the control-plane arm
Including repair calls — reliability is bought, not free
Boundary. Both arms use the same model and the same per-call settings (maxTokens 16384, temperature 0.1), but the control-plane arm may make repair calls, so this is not an equal-total-token comparison. This is cold-path reliability evidence: 2.89× total tokens buys the 57-point improvement. Repo-local audited reproduction on a clean commit. Not an official leaderboard submission, and not customer production traffic.
Where the economics live
Repeated work should not pay full inference cost every time
In real engineering workloads, genuinely novel problems are the minority; most work is the recurrence of similar changes, and agents today pay full inference cost on every recurrence. In Datafew, only results that passed the gates qualify for the reuse path — savings happen on a trusted path, not through approximate similarity matching.
20 → 5
Model calls on the same task suite
Whole-file baseline → warm-path reuse
36%
Cost per safe edit vs. baseline
Measured on the warm path only
19/20 → 20/20
Safety rate
Damaged writes: 1 → 0
Boundary. A 20-task controlled modification suite, run live against a real model with credentials. Same task set; the only variable is whether the warm path is enabled. The warm arm made 5 measured model calls, not zero — we do not claim free reuse. The cold path for novel tasks stays LLM-driven; its value is reliability, not cost. Controlled owned-repo suite, not production traffic.
Where we sit
Underneath the agent surface, not next to it
Coding agents and agent harnesses optimize generation and tool use. Datafew sits below that surface: it authorizes write scope, gates admission, verifies results, reuses only admitted work, and keeps an audit trail. Neutrality is the point — a control layer built by one platform serves only that platform’s surface.
Upstream
Model / LLM provider — inference, model-agnostic
Datafew · control plane
The agent’s full lifecycle runs inside this layer — coding agents, IDEs, and internal bots included.
authorizegateverifyreuseaudit
Downstream
Repository / CI / production — only admitted changes land
What we are
- AI infrastructure: a control plane for AI code changes.
- Constrained modification, verification gates, verified reuse, and block-level governance on the write path.
- Embedded into existing agent platforms and enterprise engineering pipelines.
What we are not
- Not a model company — we do not train or sell foundation models.
- Not another chat coding UI, agent wrapper, or prompt-optimization product.
- Not a replacement for the agents your team already uses.
Current status
Credibility before scale
We have no customers in production today, and that is deliberate sequencing for trust infrastructure. We are being selective about the first deep integrations. Everything below is how you check us rather than take our word.
Runs without our keys
The deterministic layer — structural checks, verification, reuse adjudication — requires no model credentials and re-runs as a regression suite in your own environment.
Reproducible in a day
Under NDA, your engineers clone the repository and run the verification suite to validate every first-party figure on this page. Dataset hashes and run protocol are pinned with the evidence package.
Negative results included
Capabilities we have not achieved are recorded in the same version-controlled evidence chain as the successes. We make no claims beyond current evidence.
Bringing agents to a repository that has to stay trustworthy?
That is the problem we work on. Tell us what your write path looks like today and we will tell you plainly whether we are useful yet.