The Agent Tick-Tock
Agents are advancing in alternating turns: model capability, then the harness that puts it to work. The harder shift may be learning to delegate intelligence, not learning another tool.
Trying Codex and Astra recently made the next leap in agents tangible to me: a more complete workspace and stronger models are moving them from assisted coding toward end-to-end task execution.
From collaborative coding to an agent-native workflow
Claude Code and Opus 4.5 made an important breakthrough. They brought a highly capable coding agent into the workflow developers already had. The agent could live in a terminal or IDE, understand a codebase, edit files, and run commands. Yet the basic pattern was still collaborative programming: the person defines the task, approves the actions, and reviews the code.
Codex feels different to me. It brings coding, command execution, the runtime environment, and browser interaction into a more complete workspace. Developers are no longer simply plugging an agent into their workflow. They are beginning to work inside an agent-centered one: define the task, set the constraints, then let the agent carry it through more independently, for longer, and from end to end.
The alternating progress of model and harness
It brings to mind Intel's old Tick-Tock model, where process technology and architecture took turns advancing. One side would make the first leap; the other would catch up on the next turn. Agent progress seems to have a similar rhythm, except the two alternating forces are the model and the harness.
The model sets the upper bound on what an agent can do. The harness determines whether that capability can actually reach a real task.
Claude Code first made the breakthrough at the harness layer. Opus 4.5 supplied the model capability that matched it, and coding agents truly took off. Projects such as OpenClaw and Hermes then kept pushing toward more autonomous, more end-to-end harnesses, while model capability had not fully caught up. Astra now strengthens that side of the equation, and more complete agent environments such as Codex are starting to show what they can really do.
From coding to work
From the user's perspective, agents are moving from coding into work more broadly. The main barrier in that transition is no longer, I think, the cost of learning.
The tools themselves are becoming simpler. Models are absorbing more of the interaction complexity that users once had to carry. Many prompt-engineering techniques that once demanded sustained study are steadily losing importance as model capability improves.
The difficult cost is cognitive: are we willing to change how we control work?
With Claude Code, we are still used to approving commands one by one and inspecting the code, keeping the agent in the role of an assistant programmer. In an agent-native workspace like Codex, are we ready to stop participating in every step? In some tasks, are we ready not to look at the code at all, and let the agent work independently for an extended period? Claude Code's own recent evolution is moving in that direction too.
The other barrier: professional ego
There is a deeper challenge, and it has to do with professional ego.
When an agent is only a coder, the person still designs the solution and the agent merely implements it. But are we willing to define only the problem and hand the entire solution over to the agent as well? Are we ready to take seriously the possibility that it may not only be a top-tier coder, but may also propose a better architecture than we would?
The Tick-Tock between model and harness will continue. For users, though, the next real threshold may not be learning to use a more powerful tool. It may be the cognitive shift from using a tool to delegating intelligence.
See every outcome before you decide.
Try the Demo