The short version. OpenAI published a customer story about a tax-software team using Codex to build agents that improve themselves over time. The bigger story is the pattern, not the customer: agents that learn from their own outputs and update their next pass are becoming the standard architecture for production AI work.
What to take from this. Self-improving agents are not science fiction. They are a specific engineering pattern: capture every output, score the result, feed the score back into the next prompt or policy update. Anyone building with Codex, Claude Code, or similar can use this pattern at much smaller scale.
Self-improvement is not the agent waking up and learning. It is the team around the agent collecting feedback at every step and shipping that feedback back into the next prompt, the next dataset, the next policy. The agent does not improve. The system does.
OpenAI’s case-study post on Codex-built tax agents got attention this week for the customer angle. The more useful read is the architecture underneath: the agent is not getting smarter by itself. The team is wrapping every agent run in a feedback loop, and the loop is what makes the system improve. This guide explains what self-improving agents actually are, why this pattern is becoming the standard, and how a non-engineer can think about it.
What is OpenAI Codex?
Codex is OpenAI’s coding agent. It runs inside ChatGPT and as a standalone API. Given a description of what you want, Codex writes, edits, and runs code, often across multiple files. It is OpenAI’s direct competitor to Claude Code from Anthropic and Gemini Code Assist from Google. All three products live in the same category: agents that take engineering work end-to-end, not just generate snippets.
The case-study post focuses on how a tax-software team uses Codex to do more than write code. They use it to build other agents: tax-prep workflows that ingest a return, ask follow-up questions, draft filings, and learn from corrections.
What does “self-improving” actually mean?
The phrase is doing a lot of work. It does not mean the AI model is updating its own weights mid-conversation (it is not). It means the surrounding system is feeding scored outputs back into the next pass.
- Step one: capture. Every agent run is logged. Prompt, tool calls, outputs, final answer.
- Step two: score. A human reviewer or another model scores the run. Did it succeed? Did the user follow up to correct it? How confident was the agent?
- Step three: aggregate. Patterns across thousands of scored runs surface what is working and what is not. Specific prompts get refined. Specific tools get added or removed.
- Step four: ship. The next agent generation uses the updated prompts, the updated tools, the updated training data.
Loop. Improvement compounds across cycles. The agent itself is not learning; the operators are. But from the outside, the agent appears to get better at the task.
Why does this matter for AI users?
Because the pattern works at every scale, not just inside tax-software companies.
For solo users: keep a running file of prompts that worked well and prompts that did not. The next time you start a task, lift from your own log. You are running a self-improving system of one.
For teams: a shared library of refined prompts is the smallest version of this pattern. Update the library every week based on what the team actually shipped. Newcomers inherit a year of compounded improvements.
For builders: any production AI workflow needs the capture-score-aggregate-ship loop. The agent’s quality plateaus without it. With it, the system gets measurably better month over month.
The AI Prompt Library is a packaged version of this idea: a curated, continuously updated set of prompts that have been refined through repeated use.
How does Codex compare to Claude Code?
The two products are direct competitors with different strengths.
- Codex. Tighter integration with the ChatGPT consumer surface. Strong on multi-file refactors, less opinionated about how a project should be laid out. Pricing rolled into ChatGPT Plus and Pro.
- Claude Code. Terminal-first. Strong on long-context reasoning across a repo. Better suited to teams who want CLI tools and explicit configuration via
CLAUDE.md. Anthropic just published a detailed playbook (see the Anthropic Claude Code Playbook). - Same architectural pattern. Both products operate as agents that read, plan, edit, and execute. Both benefit from the self-improving loop described above.
Are self-improving agents safe?
Safer than the alternative, with two caveats.
The alternative is a static agent that never learns and never gets better. That agent quietly accumulates errors over time as the world changes around it. Tax laws update; the agent does not. Customer expectations shift; the agent does not.
The caveats are real, though. First, a feedback loop optimized for the wrong metric will improve the agent on the wrong axis. If you score for speed, you get a fast agent that takes shortcuts. Defining the right score matters. Second, the loop concentrates power: whoever controls the score controls the agent. For high-stakes domains (medicine, finance, law) the Zero Trust framework Anthropic published this week is the right complement to the self-improvement loop. See the Zero Trust for AI agents writeup.
Where can I start using this idea today?
Smallest version: keep a notes file. Every time you use Claude, ChatGPT, or Grok for a recurring task, write down what worked and what did not. Review it once a week. Refine the prompts you reach for most.
Next version: turn your notes into a personal prompt library. The Best AI Prompts by Job and Use Case hub gives you a starting structure organized by role and artifact.
Production version: build the capture-score-aggregate-ship loop into your tool. Most observability platforms (Langfuse, Helicone, Pydantic Logfire) handle the capture step. Scoring is usually a human review queue. Aggregation is a weekly meeting. Ship is the next deploy.
Frequently asked questions
Do I need to be technical to use Codex?
To use the consumer surface inside ChatGPT, no. To build self-improving agent systems on top of Codex API, yes. The case-study pattern is engineering work, not chat.
Is Codex free?
The Codex features inside ChatGPT are bundled with ChatGPT Plus and Pro subscriptions. The API is metered usage-based, similar to how the Claude API and Gemini API are billed.
Why tax software specifically?
Tax has the rare combination of being high-stakes (errors cost real money), repeatable (the same forms every year), and bounded (the rules are written down). That makes it a near-ideal domain for self-improving agent loops.
Can the agent update itself without humans?
Some pieces, yes; the full loop, no. Automated scoring (using another model to grade outputs) is common. But promoting an updated prompt or policy to production almost always still goes through a human review gate. This is by design.
Where can I read the full case study?
OpenAI’s announcement page is the original source. The link is in the Sources section below.
Get the daily Beginners in AI newsletter
One issue a day, plain English. Coverage that focuses on the patterns and the practical takeaways, not the hype.
Get Smarter About AI Every Morning
Free daily newsletter. Built for people who want to use AI well, not chase every model.
Free forever. Unsubscribe anytime.
Sources
- OpenAI: Building self-improving tax agents with Codex
- OpenAI Codex documentation
- Anthropic: prompt engineering and feedback loops
- OpenAI Evaluations API documentation
You might also like
- Anthropic Claude Code Playbook
- Zero Trust for AI Agents
- How Anthropic Contains Claude
- AI Prompt Library
- Best AI Prompts by Job and Use Case
- AI Glossary
Two ways to go further
The AI Prompt Library
1,000+ ready-to-use prompts for Claude, ChatGPT, and Gemini. Stop staring at a blank box.
Get it for $39 →2-Hour Live AI Crash Course
A private, beginner-friendly session across Claude, ChatGPT, Gemini, and the wider landscape.
Book for $125 →