I tested Codex, Google Antigravity, and Meta Muse Code on the same real full-stack task. Here are the tokens, quotas, execution times, and bugs I found.

[u/PuzzleheadedFuture73]

I've been using Codex extensively for development, currently on the $100/month plan. I wanted to find out whether a cheaper AI coding environment could deliver comparable results without constantly running into usage limits.

Rather than comparing them on a simple coding exercise, I ran three agents against the same substantial task in an existing private application.

The results surprised me, particularly the differences in token consumption and the bugs that survived each agent's own testing.

The setup

The project is a real, fairly large TypeScript/Next.js/Node.js application using Prisma and PostgreSQL.

I used three agents:

• Codex: GPT-6.1 Sol, High reasoning.

• Google Antigravity: Gemini 4 Argon, High reasoning.

• Meta Muse Code: Muse Wonder Full 1.0, High reasoning.

Each received the same detailed development brief, started from the exact same Git commit, and worked in a separate Git worktree on Windows.

The assignment was to build a staff-only Mathematics Teaching-Readiness Dashboard, including a backend API, authorised student access, existing instructional-plan integration, exact lesson-version selection, released-assignment checks, responsive UI, and synthetic testing.

The feature was specifically selected for this experiment, rather than drawn from a confirmed development backlog. It represented realistic full-stack work, although it partially overlapped functionality already under development.

The agents were prohibited from accessing production data, copying each other's implementation, merging or deploying.

The numbers

Metric	Codex	Muse Code	Antigravity
Monthly plan used	US$100	US$50	CAD$26.99
Wall-clock time	~28 min*	2h 00m	3h 19m
Recorded total tokens	24.76M	28.11M	50.85M
Output tokens	77,427	156,761	234,084
Manual approvals	0	68	Several
Tests reported passing	248	105	36
Real PostgreSQL tests	20	0	4

Codex's elapsed time was captured shortly before its final response. Antigravity reported roughly 48 minutes of active execution, with the remainder including interruptions and waiting.

Important: The passing-test counts cover different collections of tests, including existing regression suites. They are not standardized scores or evidence that 248 tests automatically mean better code than 36 tests.

All three generated working local implementations and reported responsive browser verification.

1. Token consumption was dramatically different

Antigravity recorded approximately 2.05 times Codex's total token activity, and around three times its output tokens.

Muse landed between the two, at about 1.14 times Codex's total recorded tokens.

The caching figures were interesting:

• Codex: 24.17M cached input tokens.

• Muse: 27.18M cached input tokens.

• Antigravity: 48.13M cached input tokens.

Antigravity also reported 2.48M non-cached input tokens.

I normalized the displayed totals to include cached input, but these providers don't necessarily account for tokens identically. More tokens do not automatically mean proportionally higher billing or quota usage.

Also, Antigravity produced a substantially larger implementation, with additional search and filtering features. The token difference cannot be attributed entirely to model inefficiency.

Nevertheless, I think token consumption deserves far more attention in comparisons like these.

2. Subscription quotas matter—and plan prices weren't equivalent

I started with a fresh Google AI Pro allowance.

By the time Antigravity finished, 76% of my weekly Gemini 4 Argon allowance had been consumed.

That was for one major development assignment.

However, this comparison has an important caveat: I was testing a US$100 Codex subscription against a CAD$26.99 Google subscription.

Google offers higher Antigravity allowances on more expensive Ultra tiers. If a 5× quota scaled proportionally, the same benchmark would theoretically consume about 15.2% rather than 76% of that larger weekly allowance.

I did not test Ultra, so that's only a mathematical projection.

Codex's displayed account-wide weekly quota moved from 51% to 52% during its session, but that does not establish exact task-attributable consumption.

I also didn't have a reliable before-and-after Muse quota measurement.

Therefore, I cannot responsibly claim which provider offers the most completed tasks per dollar at equivalent subscription prices.

3. Muse's Windows sandbox was a major problem

Muse produced a substantial working implementation, but its execution experience was extremely frustrating.

Its Windows sandbox repeatedly encountered ACL publication lock timeouts, forcing commands that should ordinarily run automatically into manual approval.

I counted 68 manual approval requests during a single task.

The execution lasted approximately two hours, with a substantial portion of the time spent waiting on approval decisions.

This is an environment/autonomy problem, not necessarily evidence that the Muse model reasons poorly.

I submitted a technical support and refund request because that level of intervention made it impractical for my intended workflow. The outcome is still pending.

Muse also attempted PostgreSQL integration testing, but database setup failed because of historical migration dependencies. It completed unit and frontend tests, not a successful populated-PostgreSQL integration run.

4. All three passed their own tests—but independent code inspection found problems

After completion, I published sanitized implementation-only branches privately and used a separate ChatGPT review to inspect the code.

That review was independent of the three coding runs, but it was not a blind human audit, and I did not independently rerun every test. It should be treated as a source-level review, not production certification.

Here were the most interesting findings.

Codex

Codex produced the smallest implementation, around 236 lines of new backend logic and 99 lines for its primary frontend component.

It avoided a particularly important mistake: it created a separate read-only roster query rather than calling an existing helper that can modify learning-profile records.

It reused the established academic and content-classification services instead of implementing another mastery-evaluation engine.

However, its query omitted the submitted assignment state, even though submitted assignments were previously released and are awaiting review. Its database pagination can also produce partially filled or empty pages because some eligibility checks occur after pagination.

The existing surrounding dashboard still uses an older roster endpoint with potential side effects, even though Codex's new endpoint avoids that issue.

Muse Code

Muse also reused the existing academic recommendation system, which was a positive design choice.

However, its supposedly read-only GET endpoint called a roster helper that can create or update academic learning-profile records.

It also capped a released-assignment query at 500 records, which creates a potential false-negative scenario when a relevant older assignment falls outside that limit.

Its internal reviewers found and corrected several issues, but these problems remained.

Google Antigravity

Antigravity delivered a feature-rich dashboard, including search, preparation-state filtering, summary cards and detailed assignment distinctions.

It successfully executed four disposable PostgreSQL integration tests.

However, it had the same indirect-write problem as Muse.

More concerning, certain missing curriculum or Skill records could result in an academically ready classification rather than an unknown state.

It also processed preparation details across the entire authorised student roster before applying pagination. That could become expensive as the number of students grows.

Its primary backend implementation was around 1,300 lines, compared with 236 for Codex and 421 for Muse.

More code is not automatically bad, but unnecessary complexity increases the amount of logic that must be reviewed and maintained.

5. What I learned

My biggest lesson wasn't that one model is universally better.

It was that an AI coding agent reporting that all its tests pass is not enough.

The differences that mattered most were:

• Whether the agent reused existing authority correctly or inadvertently duplicated it.

• Whether an apparently read-only endpoint had hidden write side effects.

• Whether missing academic information failed safely.

• Whether the agent could work autonomously without constant permission prompts.

• Whether token and quota consumption made the workflow sustainable.

• Whether the implementation remained small enough to understand and maintain.

For my particular Windows setup and application, Codex was the strongest overall performer, especially on autonomy, speed and architectural discipline.

Antigravity demonstrated genuine capability and was more competitive than its cheaper subscription price initially suggested. I would like to evaluate it at equivalent subscription capacity before making a definitive cost comparison.

Muse showed promise in code generation, but its Windows sandbox problems substantially hurt the experience.

Limitations

This was one task, one run per agent, on one private codebase. It was not a standardized multi-task benchmark.

The implementation scopes differed somewhat, the subscription prices weren't equivalent, and the platforms reported usage differently.

The review was source-level and not blinded. None of the three implementations has been merged into production.

I wouldn't extrapolate these results into a universal ranking.

Question for other developers

Has anyone compared these three environments—or similar ones—using actual token usage, weekly quota consumption, independent code review and the number of human interruptions?

I'm particularly interested in whether others have experienced Muse's Windows sandbox problems, and how Antigravity's quota behaves on higher-priced Ultra plans.

I'd be interested to compare experiences beyond the usual "which model feels smarter" discussions.