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.
Wave Field Attention
Long-context attention for coding agents that need to remember repositories, issues, traces, and tool calls without quadratic rent.
The architecture for
billion-token context.
Wave Field is a sub-quadratic breakthrough for AI's last mile: persistent working context. Instead of comparing every token to every token, information moves through a causal field, making codebases, logs, tools, and long-horizon reasoning feel native 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
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) |
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 a longer 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.
06 / 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.
07 / 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.
08 / Agent preview
Want agents that stay with the repo?
Build with us.
Join the private preview for coding-agent systems built on field attention.