tree.map
Repo
Keep code structure in working memory
Symbols, files, tests, and docs can contribute to one field state instead of competing for a narrow prompt window.
Live · 125M field-attention preview
Wave Field
Attention
Long-context attention for coding agents that remember entire repositories: issues, traces, tests, and tool calls held in one continuous field, without quadratic cost.
↓ Move your cursor through the field
O(n log n) · FFT wave convolution · 128K context · 2.2M tok/s · sub-quadratic · full-repo reasoning · causal oscillator kernel ·
01 / Capability
The first LLM that understands your entire codebase.
A sub-quadratic breakthrough for full-repo reasoning. Code, issues, tests, diffs, traces, and tool-call history live in one working field, not a window you keep paying quadratically to widen.
wavefield@repo~/auth❯ Find the auth regression across these three traces, update the failing tests, and explain the patch.
→ traced 3 sessions · 41 tool calls held in context
→ regression: token refresh races logout in auth/session.ts:142
→ patched the guard, updated 6 failing tests in auth.test.ts
→ root cause + diff summary ready ✓
02 / Throughput
Long context gets faster, not slower.
Wave Field uses FFT-based propagation, so the expensive setup is amortized as context grows. Throughput stays high deep into the window.
0.0M
tok/s throughput
at 128K context
at 128K context
0×
faster than standard
attention at length
attention at length
0K+
tool calls held in
working memory
working memory
0K
context window
in the preview
in the preview
Tokens
Standard attn
Wave Field
Result
4K
1.0× cost
1.0× cost
near-equal
32K
~16× cost
3.1× cost
5× faster
128K
~256× cost
12× cost
21× faster
03 / Model
A repository is not a prompt.
It is a field of signals.
Coding agents juggle symbols, commits, tickets, traces, and failed attempts. Wave Field writes all of it into a shared causal medium instead of stacking a pile of retrieved snippets.
loop.state
Tasks
Carry state through long agent loops
Debug traces, failed attempts, and reviewer constraints can remain active while the agent searches, edits, and verifies.
signal.emit
Tools
Feed agent actions with grounded context
Expose repo memory to planners, code editors, test runners, and review agents through practical runtime interfaces.
04 / Mechanism · scroll to step through
Tokens scatter in. Waves do the work.
Tokens write into a shared medium, waves propagate through the field, heads couple, and token positions read the result back out.
❯
Scatter
token values enter field space
❯
Propagate
FFT wave convolution
❯
Couple
heads interact during attention
❯
Gather
field returns to tokens
scatter.module
O(n log n)
05 / Economics
150×+ lower long-context compute at scale.
Quadratic attention pressure dominates spend as context grows. Wave Field replaces it with O(n log n) propagation, so training and inference economics improve as the window widens.
0×+
lower compute on long-context workloads vs. standard attention
O(n log n)
attention complexity replaces the O(n2) wall on context
Workload
Standard
Wave Field
Attention compute
O(n2)
O(n log n)
128K forward pass
256× cost
12× cost
Long-context training
quadratic blow-up
scales near-linear
06 / For builders
What agents can do with a real memory.
01❯
Query a repo with citations
Ask across the whole tree and get answers grounded in exact files and lines.
wf query --cite
02❯
Debug across traces & diffs
Correlate failing runs against recent changes without re-feeding context.
wf debug --trace
03❯
Prepare PRs and tests
Draft changes and the tests that cover them in one continuous pass.
wf pr --with-tests
04❯
Migrate APIs in bulk
Apply a coherent change across hundreds of call sites in a single session.
wf migrate --api
05❯
Explain architecture drift
Surface how a system diverged from intent across its commit history.
wf explain --drift
06❯
Keep long-running state
Hold an agent's working memory across thousands of steps in one field.
wf session --persist
07 / Open
Open primitives for people building agents.
The important objects (a damped wave kernel, a field state, coupling across heads, and efficiency accounting) are things agent builders can reason about directly.
Reference implementation
A compact, readable kernel you can drop into an existing transformer stack. Scatter, propagate, couple, and gather are exposed as discrete, inspectable ops, with no hidden attention matrix to debug.
Schematics & kernel
Each head is a causal oscillator with three learnable scalars: omega controls pattern scale, alpha controls range, phi gives heads distinct responses. The same compact equation expresses local syntax and long document structure.
Agent-memory tracing
Inspect what an agent retained across a long run. Because every tool call deposits a signal in the field, you can trace which past events shaped a given decision instead of guessing at a context window.
Preview access
Request a preview.
We're onboarding teams building serious coding agents. Tell us what you're building and we'll get you into the field.