Download
BLOG

Engineering notes from the Neox team

Trade-offs, methods and implementation details behind the product.

23 posts
Same Opus 5.5: rounds used by Claude Code, Neox before, and Neox after on the same tasks
LatestEngineeringSep 30, 20269 min read

Notes on what we optimized in the Neox agent this round

On the same model Neox took 3–6x the rounds of Claude Code; we found why and cut the gap to 1–1.5x.

Read more →
Security8 min read

A permission gradient for agents: provenance tiers × action risk

Auditing ourselves, we found the approval gate only looked at what an action does, never at who asked for it. `send_imessage` on its own is harmless; users ask for it all day. The dangerous case is sending a message right after reading a web page. This post is about adding the second axis: provenance tagging, session tainting, an exit gate, and why a classifier may only raise severity, never grant approval.

Engineering7 min read

Should the agent resume on its own after a crash? We ran it for five months, then removed it

Automatic resume after crashes ran for five months; now we repair history and let the user continue.

Tools18 min read

From line numbers and hashes to a read ledger: seven changes to Neox's edit tool

Seven changes to the edit tool, from line numbers and hashes to a read ledger, and the cache-coherence idea behind them.

Engineering10 min read

Running the agent on desktop for 10 hours: first we fixed 6 bugs in our own monitor, then 3 P0s

Ten hours on the desktop: six fixes to our own monitor first, then three P0s.

Cache9 min read

Same context structure, different wiring per model: the three cache protocols

The structure and discipline from the previous posts land differently on each model: Claude wants you to pin breakpoints, the OpenAI line wants you to stop touching bytes, Gemini has a separate API. We caught it live on DeepSeek — the first 35 messages byte-identical, broken at message 36, because of one extra Anthropic-style pin.

Cache9 min read

How you structure an agent context decides whether each turn bills at 10% or full price

A request ships four segments of context, and the cache only eats contiguous bytes from the head. What each segment is, why order is cost, and the three things we changed: 149 tools down to 20 resident, a byte-stable system block, and three readings that tell you where a collapse came from. With 509 measured runs.

Tools8 min read

The fastest-growing part of your context: tool results, and the ledger we built for it

Of the four context segments, system and tools are ones you can nail down. History is not — it only grows, and most of that growth is tool results. Re-reading the same 120-line file costs another 2,284 tokens without a ledger, or 53 with one. How we manage that segment: why the version stamp is mtime+size instead of a content hash, and one broken link we nearly missed.

Tools8 min read

readfile had 24 parameters and models used 3: auditing tool parameter usage

Measuring tool parameter usage from real logs: readfile had 24 parameters, models used 3.

Engineering9 min read

Two sub-agents with the same name, one running 20 minutes with zero tool calls: eight root causes

A sub-agent ran 20 minutes with zero tool calls; eight problems were behind it.

Engineering6 min read

Our benchmark was punishing "ask first": a mistake in how we scored

Claude Code stopped to ask about an ambiguity and scored the baseline; the scoring was wrong.

Engineering9 min read

Same model, why does it feel better in Claude Code? Taking "feel" apart

Why the same model felt smoother in Claude Code, taken apart with real session data.

Engineering10 min read

ReAct is a product of 2022: re-deriving the agent loop from model physics

Re-deriving how the agent loop should be designed from the physical properties of models.

Engineering8 min read

One night of benchmarks, four P0s: npx hanging for 8 minutes, and two prompt lines worth 4.7x

One night of benchmarks found four P0s, each fixed in a few lines.

Engineering11 min read

28 experiments on multi-agent clusters: speed is set by the serial part, and over-constraining makes a cluster slower than one agent

28 experiments comparing single agents with clusters: cluster speed is set by the serial part.

Engineering9 min read

Rebuilding the agent core: one pipeline, one state machine, concurrency decided per call

On April 18 we rebuilt the execution paths, the main loop and concurrency decisions in one day.

Engineering6 min read

We wrote 1,800 lines of "auto-test, auto-fix" and reverted all of it 90 minutes later

We wrote 1,782 lines of test-driven self-healing and reverted all of it 90 minutes later.

Engineering8 min read

GPT kept stopping halfway: we added a pile of gates, then removed them within a day

GPT stopped halfway; we added completion gates, removed them the next day, and fixed the system prompt structure instead.

Engineering9 min read

Our first go at multi-agent: four run modes in one week

In one week in January we built a supervisor agent plus collaborative, Pipeline and self-organizing modes.

Engineering7 min read

Our CLI renderer changed twice in three weeks: off Ink and back again

We left Ink for our own terminal renderer, then moved back a week later: 8,830 lines down to 1,868.

Engineering8 min read

First lessons from supporting many models: every tool call needs its result

Four errors from supporting many models, all caused by tool calls and results not lining up.

Engineering8 min read

The CLI stopped taking input after sitting idle: our December freeze hunt

What users called "freezing" was four different problems; this is how we tracked each one down.

Engineering8 min read

A small feature took the agent 42 iterations: notes from our first month

A small feature took 42 iterations; we split the log by round and fixed editing, reading, loop detection and the prompt.