Codex needs more than context: a proposal for Reference, Attention Core, and convergence
I have been thinking about a problem that appears when Codex is used for longer, more iterative projects.
The problem may not simply be that AI needs more context.
It may need a better way for the user to control what should be seen, what actually matters, what has already been decided, and where the next change should happen.
My proposal is a simple working model:
Reference → Attention Core → Execution → Fixed State → Convergence
1. Reference: “I want you to see this.”
Today, moving information between conversations, files, projects, and AI results often means copying and pasting it, then explaining where it came from.
But copying is not really what the user wants.
The user usually means:
“This already exists. I want you to see it and understand its relationship to what we are doing now.”
So I imagine a more universal Reference mechanism.
For example:
- @ File — reference an existing file
- @ Result — reference a previous AI result
- @ chat — reference an important part of a previous conversation
- @ agent — ask another agent to contribute
- @ Attention — expose confirmed user intent
- @Project— continue working on an established work object
The important distinction is:
Copying creates a new piece of information.
Reference preserves the relationship to something that already exists.
2. Attention Core: “This is what I actually care about.”
A long conversation contains many things that are not equally important.
Some are experiments.
Some are suggestions.
Some are temporary.
Some are decisions.
Some are things the user explicitly confirms:
“Yes. This is what I want.”
I imagine these confirmed pieces becoming part of an Attention Core.
This would not simply be another memory system.
It would be a dynamic layer representing what the user currently considers important for the project.
It could:
- add important decisions
- modify them
- replace outdated ones
- merge similar ideas
- remove duplicates
- preserve timestamps, versions, sources, and relationships between changes
In other words:
Evolution should not mean forgetting.
The purpose is not to remember everything.
The purpose is to reduce the user’s repeated judgment cost.
3. Execution: “What did you actually do?”
For long-running AI work, a final diff is often not enough.
The user may also need to understand:
- What did the agent do?
- Why did it do it?
- What problem was it trying to solve?
- What changed?
- What was verified?
- What happened after the change?
This becomes especially important when multiple agents are involved.
For example:
Agent A proposes → Agent B analyzes → Agent C executes → Agent D verifies
The system should make this chain understandable rather than turning it into an increasingly noisy stream of agent activity.
4. Fixed State: “This has been decided.”
One of the most important things in an iterative AI project is not only knowing what can still change.
It is knowing what should no longer change.
After the user confirms a result:
“Yes, keep this. Do not change it while working on the next part.”
That result could become a Fixed State / Anchor.
Then the next iteration can explore around that anchor instead of accidentally reopening decisions that were already settled.
Possible actions could be:
Keep / Revert / Continue / Lock
This creates a different kind of development loop:
Explore → Judge → Fix / Lock → Explore around the anchor → Judge → Lock → Converge
5. Project Convergence
This leads to the larger question:
Is the project actually getting closer to what the user wants?
An AI can keep producing work without necessarily getting closer to the goal.
Continuing to do things ≠ continuously getting closer to the target.
So I think a project should be treated as a work object, not simply a folder or path.
A project could contain:
- Files
- Intent
- History
- Fixed State
- Current Work
- Agents
- Reusable results
The system knows paths.
The user cares about references and continuity.
Paths belong to the system; references belong to the user interface.
REFERENCE
What should you see?
↓
ATTENTION CORE
What do I really want?
↓
EXECUTION
What did you do?
↓
FIXED STATE
What has been decided?
↓
ITERATION
Where should we change next?
↓
PROJECT CONVERGENCE
Are we actually getting closer?
The deeper question behind this proposal is:
Can AI continuously follow human attention and intent, while also helping prevent human attention from being pulled off course by the AI itself?
And for long-running projects:
Can an AI project that constantly changes gradually converge through human judgment, rather than becoming increasingly misaligned?
I don’t see this as a complete product specification. It is a conceptual model for discussion.
I’ve attached a short visual version of the idea.
I’d be very interested in hearing how the Codex team and other developers think about this problem.