Provider-independent coding infrastructure v1.3.6 shipped

The engineering layerfor AI coding agents.

Trebell Code gives capable models a dependable engineering environment: repository intelligence, deterministic tools under real policy, durable state, verification with evidence, recovery, and efficiency infrastructure measured in the things users actually pay for — tokens, turns, tool calls, retries, and context.

Desktop
Windows · macOS · Linux
Apache-2.0
Open core
Multi-runtime
One engineering layer
Evidence-first
Verify before “done”

The models got better.
The environment around them did not.

Most coding-agent frontends answer one question: “How do I talk to this model?” Trebell is built around a harder one: “How do I give different coding agents the same dependable engineering environment without pretending they all support the same things?”

⌘01 / 03

Context becomes a tax.

Dumping more of a repository into every turn burns tokens, damages cache locality, and often gives the model less signal rather than more.

  • IN TREBELL Repository intelligence is retrievable instead of eagerly stuffed into every prompt.
  • IN TREBELL Large outputs can be virtualized while keeping hot previews available to the model.
◇02 / 03

Agents operate in brittle worlds.

Files, terminals, Git, worktrees, credentials, processes, permissions, side effects, crashes, and provider differences all become part of the agent’s actual runtime.

  • IN TREBELL Deterministic tools sit behind shared policy instead of bespoke provider behavior.
  • IN TREBELL State, source control, process handling, and recovery belong to the harness.
✓03 / 03

Completion is not proof.

An agent saying “done” is not the same as the software being correct. Real engineering needs evidence, not confidence theater.

  • IN TREBELL Verification evidence is part of the execution loop rather than an optional afterthought.
  • IN TREBELL Repairs are measured end-to-end instead of celebrating isolated micro-metrics.

One engineering control plane.
Multiple capable agents.

Trebell owns the durable environment around the model. Runtime adapters can change; the engineering substrate stays coherent.

01 ⌘

Repository & Context Intelligence

Understand what matters, keep the rest retrievable, and preserve stable prompt prefixes where possible.

repo graphretrievalvirtualizationcache-aware
02 ◇

Tools, Policy & Execution

Deterministic engineering capabilities with permissions, process isolation, secrets, source control, and side-effect control.

terminalfilesgitpolicyMCP
03 ✓

State, Trace & Verification

Durable threads, checkpoints, crash recovery, usage telemetry, evidence capture, and verification before completion.

statetracerecoveryevidence
Runtime adapters
Trebell NativeCodexClaude CodeOpenCodeACP+ future agents

Give the model what matters.
Keep the rest retrievable.

Bigger prompts are not automatically better prompts. Trebell treats context as an engineered resource: expensive enough to measure, stable enough to cache, and selective enough to preserve signal.

  • Progressive discoveryExpose specialized tools and MCP capability only when the task needs them.
  • Large-output virtualizationKeep bulky command output retrievable instead of replaying it through every turn.
  • Stable identityKeep project/thread state independent of whichever model provider is active.

Optimize useful coding work.
Not vanity metrics.

Trebell measures the harness where it can actually control the result: provider input, cache behavior, model turns, tool calls, failures, retries, and unnecessary inference. No pretending noisy upstream provider latency is a harness breakthrough.

  • Token & cache telemetrySee where context is paid for, reused, or wasted.
  • Tool/retry accountingMeasure how much orchestration the model needed to reach a verified result.
  • Regression disciplineAn optimization only counts when the end-to-end task gets better.

Benchmarks people
actually care about.

Workload-specific measurements from Trebell development. They are evidence of direction and engineering discipline, not universal promises.

≈71% lower Failure-repair benchmark 31.9k → 9.2k

Provider-input tokens

Same independently verified outcome with dramatically less input replay.

Same benchmark
Failure-repair benchmark 10 → 4

Model turns

Fewer inference loops needed to recover and verify.

Same benchmark
Failure-repair benchmark 17 → 6

Tool calls

Less orchestration overhead around the actual engineering work.

Same benchmark
Noisy-output repair ≈18%

Lower provider input

Reduced replay on a 92 KB noisy-output repair workload while preserving verification.

Recipe-restricted request 11 → 1

Initially visible tools

Progressive capability exposure instead of dumping the full tool surface up front.

Optimization discipline Rejected

Schema compression that regressed the full task

A smaller schema looked better in isolation, but increased end-to-end model work. Trebell did not ship the “win.”

A serious engineering environment.
Not a chat box with a terminal bolted on.

Projects, source control, real terminal sessions, durable agent threads, verification evidence, usage accounting, and provider-independent runtime control in one desktop workspace.

Trebell Code desktop workspace in dark mode Trebell Code desktop workspace in light mode
Actual Trebell Code interface captured from the current desktop build.

Better models help.
Better systems compound.

Provider-independent engineering infrastructure for coding agents that need to work on real software, not just produce plausible text.