Wave Field measured throughput at 32K context, up from 724K tok/s at 2K.
Wave Field Attention
Long-context attention for coding agents that need to remember repositories, issues, traces, and tool calls without quadratic rent.
The first LLM that can
understand your entire codebase.
Wave Field is a sub-quadratic breakthrough for full-repo reasoning: code, issues, tests, docs, traces, and long task history can live in one working field without quadratic attention cost.
Request breakthrough preview ->wavefield.agent
Find the auth regression, update the failing tests, and explain the patch.
- Retrieved repo map, recent diffs, and CI trace
- Followed signal across middleware, tests, and issue history
- Drafted patch plan with files, risks, and verification steps
03 / Long-context speed
Long context gets faster, not slower.
Wave Field uses FFT-based attention, so the expensive setup is amortized as context grows. In the long windows that matter for repositories and agent memory, throughput rises while standard attention falls.
Wave Field improves from 2K to 32K, while native standard attention drops about 7x over the same range.
Flash Attention still wins on short prompts. Wave Field wins once context becomes long enough to matter.
Standard transformers run out of memory at repo-scale windows. Wave Field runs the core attention path around 27GB.
Flash Attention caveat
Fair comparison: Flash is optimized, but still slows as context grows.
These Flash numbers are estimates from the native-attention baseline with a 2-4x memory-I/O improvement. The key signal is the curve: Wave Field gets better amortization at long context.
| Context | Flash est. | Wave Field | Readout |
|---|---|---|---|
| 2K | ~1.4M tok/s | 724K | Flash wins short prompts |
| 8K | ~700K tok/s | 1.6M | Wave wins ~2.3x |
| 32K | ~200K tok/s | 2.2M | Wave wins ~11x |
| 128K | ~50K tok/s if it fits | 1.6M | Wave wins ~32x |
Retrieval workloads add a persistent-field soft attention path with O(N x G) cost. That path still needs optimization; the core language-model attention result is the long-context speedup above.
04 / Agent memory
A repository is not a prompt. It is a field of signals.
Coding agents need to keep symbols, commits, tickets, traces, tests, and failed attempts in play. Wave Field turns that context into a shared causal medium instead of a pile of retrieved snippets.
| Agent need | Short-context assistant | RAG wrapper | Wave Field |
|---|---|---|---|
| Working memory | Current file or chat window | Chunk recall at query time | Continuous repo field |
| Long task state | Lost between tool loops | Rebuilt from search | Persistent propagated signal |
| Failure mode | Forgets constraints | Misses cross-file dependencies | Couples related evidence |
| Economics target | O(n^2) dense attention | Index plus model context | O(n log n) |
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.
Tasks
Carry state through long agent loops
Debug traces, failed attempts, and reviewer constraints can remain active while the agent searches, edits, and verifies.
Tools
Feed agent actions with grounded context
Expose repo memory to planners, code editors, test runners, and review agents through practical runtime interfaces.
05 / Agent workflows
What coding agents can do with longer, cheaper memory.
Inspired by agent-native product surfaces: describe the work, let the system gather context, and keep enough memory alive to finish the change instead of restarting every few files.
Give agents a field over the whole codebase.
Use Wave Field to study how code symbols, test failures, docs, and issue history can propagate through a compact long-context state.
Open reference implementation->Prototype coding agents that stay with the task.
Explore field propagation for multi-step coding workflows: search, edit, test, review, and explain without collapsing into a fresh prompt each turn.
Discuss agent preview->Query a repo with citations
Ask why a module works the way it does and trace the answer back to files, commits, and tests.
Debug across traces and diffs
Keep logs, stack traces, recent changes, and failing assertions active in one investigation.
Prepare PRs and tests
Plan the patch, edit the right files, update tests, and summarize verification in context.
Migrate APIs in bulk
Follow usage patterns across packages without losing the exceptions that make migrations hard.
Explain architecture drift
Surface where implementation and intended design diverged across a long project history.
Keep long-running state
Carry constraints from yesterday's issue thread into today's edits, tests, and review loop.
Turn issues into patch plans
Connect bug reports to relevant code paths and propose scoped, testable changes.
Review changes against intent
Compare diffs to original goals, product constraints, and prior agent decisions.
07 / Platform
Open primitives for people building agents.
The important objects are inspectable: a damped wave kernel, a field state, coupling across heads, and efficiency accounting that agent builders can reason about.
08 / Built for code
Built for systems where code context is infrastructure.
Wave Field sits between model architecture and agent runtime design. The work matters when the hard part is not a bigger prompt, but a better memory substrate for software work.
RepoFiles, tests, docs, and issues contribute to a shared representation instead of isolated snippets.
AgentLong-running workflows keep task state alive while tools search, edit, test, and review.
ScaleFFT-based propagation keeps the architecture pointed at practical full-repo context windows.
09 / Agent preview
Want agents that stay with the repo?
Build with us.
Join the private preview for coding-agent systems built on field attention.