DEV Community: Hirak

Orkas: An Open-Source AI Agent Team You Run on Your Own Machine

Hirak — Wed, 09 Sep 2026 14:30:00 +0000

Somebody submitted Orkas through our tool form last week. Most of what comes through that form is off-topic and gets a polite no, but this one is squarely the kind of thing we cover, so I spent a morning verifying what it actually is. Disclosure up front: it arrived as a free submission, nobody paid anything, and Orkas has no idea I'm writing this.

Orkas is an open-source desktop app that runs a team of AI agents on your own machine. A Commander model takes your goal and farms the work out to specialist agents: DeepResearcher for sourced research, ContentWriter, PptMaker for actual editable .pptx files, OfficeWorker for Word and Excel, VideoStudio, a UI designer, an SEO auditor. Nine ship installed, and there's a marketplace that claims thirty.

The pitch is the same one every agent product makes in 2026. What made me look closer is the stuff that's checkable.

The repo is real and actively worked on. github.com/Orkas-AI/Orkas, MIT license, 1,796 stars when I checked on September 7. Their own site says "1.6k+", which means their marketing understates their numbers. That's rare enough that I noticed. Eight releases between July 6 and August 29, the latest one improving Commander reliability and Linux source builds. A real shipping cadence, in other words, not a launch-week repo that went quiet.

The bring-your-own-keys model is the sane kind. You plug in your own Claude, OpenAI, Gemini, DeepSeek, Kimi, GLM, Qwen, MiniMax or Doubao keys, or point it at Ollama or LM Studio through an OpenAI-compatible endpoint, and the README says model calls go straight to the provider, never through Orkas servers. There's an optional credits plan if you'd rather not manage keys, and some of those paid tiers are still marked "planned" on the site, along with remote control and team collaboration. So the free open-source core is the shipped product; parts of the paid layer are still promises.

Requirements are ordinary: Node 20+, macOS on Apple Silicon or Intel, Windows 10+, Linux only from source with glibc 2.34+. No musl distros at all.

Two things gave me pause. The packaged desktop app requires an account sign-in on first launch, which is a strange requirement for something calling itself local-first. The source build skips the account layer entirely, so the escape hatch exists if you're willing to build it yourself. And the issue tracker has just two open issues, one of them a Chinese-input bug on WSL that's been sitting since May with no visible maintainer reply. Two issues could mean solid software or it could mean a small user base. With 1.8k stars, I'd guess mostly the latter.

What I have not done yet is run the nine agents through real work and judge the output. That's the only question that actually matters with agent tools, because every one of them demos well. It's a longer job, and it's the follow-up this piece earns if there's interest. What I can tell you today is narrower: every claim I could verify checked out, and the code is open, moving, and buildable without their account or their billing.

If you're already paying for API keys and you're curious what a coordinated multi-agent setup does with them, this is one of the few where you can read the source before you trust it with anything.

Verified September 7, 2026 against the GitHub repo, releases page, issue tracker, and orkas.ai. Re-checked when something moves.

Netlify Free Tier & Pricing in 2026 — The Real Limits

Hirak — Mon, 24 Aug 2026 14:30:06 +0000

Netlify's free plan is $0 a month and gives you 300 credits. That's the entire allowance. Not gigabytes, not build minutes — 300 credits, drawn down against a rate card where a production deploy costs 15 credits, bandwidth costs 20 credits per GB and 10,000 web requests cost 2. When the 300 are gone, Netlify doesn't throttle you and doesn't bill you. Every project on the team is paused until the next billing cycle starts.

Last verified: 22 August 2026.

What one credit buys — Netlify's credit rate card, verified 22 August 2026

What one credit buys on Netlify: the per-unit credit rate card, identical on Free, Personal, Pro and Enterprise. AI inference is the outlier at 180 credits per $1 of model spend; everything else metered — bandwidth, deploys, compute, requests — costs 20 credits or less. Verified 22 August 2026.

If you've read that Netlify's free tier includes 100 GB of bandwidth and 300 build minutes, that's the Legacy free plan, and it's still true if your account is old enough. Since 4 September 2025 every new Netlify account goes onto a credit-based plan, and accounts predating that are what Netlify now calls Legacy pricing plans. The old quota numbers survive in the Legacy table and nowhere else. They're at the bottom of this page, so you can tell which world a figure came from.

The free tier, every published limit

This is the credit-based Free plan, not Legacy. Everything here comes from Netlify's own docs and pricing page, re-fetched on 22 August 2026.

Free-plan limit	Value
Monthly credits	300 credits/month, hard limit
Buying more credits	Not available — no auto recharge, no credit packs
Concurrent builds	1, with no add-on option on Free
Build minutes	Not metered at all on credit plans
Production deploys	15 credits each
Deploy Previews and branch deploys	0 credits, unlimited
Bandwidth	No GB allowance published; billed from the same 300 credits at 20 credits per GB
Web requests	No request allowance published; 2 credits per 10,000
Functions	No invocation allowance published; billed as compute at 10 credits per GB-hour, memory fixed at 1024 MB
Edge functions	Not counted as compute; metered through web requests
Form submissions	Free and unlimited
Team members	1 free member, 1 Team Owner, no additional seats purchasable; unlimited free Git Contributors on public repos
Reviewers	Unlimited
Projects	500
Preview Servers	1
Netlify Database	3 databases, 20 branches per database, 48 compute units per billing period, 5 GB written, 5 GB database bandwidth, 5 GB storage per database
Observability	1-day history
Web analytics & RUM	1-day retention
Functions log retention	24 hours
Edge Functions log retention	24 hours
Audit logs	Not available (Pro only, 7-day history)
Support	Standard email support
SLA	None published for Free; the 99.99% SLA is Enterprise only

Sources for those rows: how credits work, credit-based pricing plans, functions configuration, database billing and the pricing page.

The 300 is a per-cycle grant that resets, not a balance you accumulate. Netlify: "In general, monthly plan credits do not roll over, but if you have a Pro plan with 5,000 monthly credits or higher, then any leftover credits can roll over for an additional month." So on Free, unused credits are gone at the end of the cycle, and rollover is a Pro-and-above feature gated at 5,000 credits.

One detail worth knowing before you plan around a reset date: the cycle is not the calendar month. The billing FAQ says "the start of your monthly billing cycle is customized for when you open and start your Netlify team account." If you're paused and waiting, the date that matters is your signup anniversary, not the 1st.

What one credit buys

The rate card is identical on Free, Personal, Pro and Enterprise. I checked the Enterprise-specific page separately: it lists six rates — production deploys, previews, compute, AI inference, bandwidth and web requests — and every one matches the self-serve card exactly, which is unusual and worth knowing before a sales call. It carries no Forms row; the "free and unlimited" wording for Forms comes from the self-serve card's "Free for all credit plans".

Meter	Credit cost
Production deploy	15 credits each
Deploy Preview / branch deploy	0 credits
Compute (functions, scheduled, background, Preview servers, Agent Runners, database)	10 credits per GB-hour
AI inference (Agent Runners, AI Gateway)	180 credits per $1 USD of model usage
Form submissions	Free on all credit plans
Bandwidth (web + database)	20 credits per GB
Web requests	2 credits per 10,000

Three of those moved on 14 April 2026, and not all in the same direction: bandwidth went from 10 to 20 credits per GB, compute from 5 to 10 credits per GB-hour, and web requests got cheaper, from 3 to 2 credits per 10,000. Same date, form submissions went from 1 credit each to free and unlimited. If you built a cost model before April, your bandwidth and compute lines are half what they should be.

Failed deploys cost nothing. So do rollbacks to a previous production deploy — only a successful production deploy spends the 15.

The arithmetic Netlify doesn't do for you

This is the part I want to be careful about, because it's where every other page on this subject goes wrong. Netlify publishes no gigabyte, build-minute or invocation allowance for any credit-based plan. It publishes a credit count and a set of per-unit rates. Any sentence of the form "the Netlify free tier gives you N GB" is somebody's division, including mine below.

So here's my division, shown in full, on Netlify's published figures.

If you spent all 300 free credits on one thing	The arithmetic	Ceiling
Bandwidth	300 ÷ 20 credits per GB	15 GB
Production deploys	300 ÷ 15 credits each	20 deploys
Web requests	300 ÷ 2 credits per 10,000	1.5 million requests
Function compute	300 ÷ 10 credits per GB-hour, at the fixed 1024 MB Free function size	30 GB-hours, so 30 hours of runtime
AI model spend	300 ÷ 180 credits per $1	about $1.67

Every one of those is a ceiling in a degenerate case, not an allowance, and they're mutually exclusive. You cannot have 15 GB of bandwidth and 1.5 million web requests, because the same traffic bills against both meters at once. Serving 15 GB while making zero requests is not a thing. A small site with a handful of deploys a month has real headroom here; an Agent Runner has none, because $1.67 of model spend is a couple of runs and the sandbox the agent works in bills to the compute meter on top of the inference meter. If you're budgeting model calls specifically, the free AI API rate limits page is a better starting point than a Netlify credit balance.

What happens at zero

This is the question that costs people money, so here it is verbatim from Netlify's billing FAQ:

Once your monthly credit allotment is used up for all web projects on your team, all of your web projects (sites/apps) are paused and visitors to your web projects will find a Site not available page at each of your web project's URLs. In addition, while your web projects are paused, they will not receive new web requests, web traffic, or form submissions and you cannot trigger new production deploys.

Not throttled. Not auto-billed. Hard-stopped. And the blast radius is the whole team: "if one site/web project exceeds its limits, all sites/projects on your account will be paused." One runaway function on a scratch project takes down everything else on that account. Free has no escape hatch — no auto recharge, no credit packs — so you wait for the cycle to reset, when projects resume automatically, or you upgrade.

Personal and Pro can top up instead: 500 credits for $5 and 1,500 credits for $10 respectively, the same rate whether it's auto recharge or a manually bought credit pack, and purchased credits never expire. Credits are drawn soonest-expiry-first, so your monthly allotment burns before your packs do.

Warnings arrive at 50%, 75%, 90% and 100% of the allotment. Or at 50%, 75% and 100%, depending on which Netlify page you're reading — see below.

The paid bands

Plan	Price	Credits included	Top-ups
Free	$0 forever	300/month, hard limit	None
Personal	$9/month	1,000/month	500 credits for $5
Pro	from $20/month, unlimited members	from 3,000/month	1,500 credits for $10
Enterprise	Custom	Custom	Custom

The Pro card on the pricing page says "$20 /month" and lists five credit amounts in a selector. It does not price four of them. Those prices live only in the docs:

Pro credits/month	Price	Rollover
3,000	$20/mo	No
5,000	$33/mo	Yes
10,000	$63/mo	Yes
15,000	$95/mo	Yes
20,000	$126/mo	Yes

Rollover starts at the 5,000-credit tier and unused credits survive exactly one extra cycle. The $20 Pro tier gets none. Pro seats became free and unlimited on 14 April 2026, so the $20 is for the whole team; Legacy Pro is still billed at $19 per team member per month, which is a different plan with a coincidentally similar number. Concurrent builds: 1 on Free with no way to buy more, 1 included on Personal, 3 on Pro, $40 a month for each additional build on the two paid plans.

Netlify does not publish an Enterprise dollar price or an Enterprise credit allotment. I looked on the pricing page, pricing.md, the credit-based plans doc and the Enterprise credits doc; all four say Custom or point at Contact Sales.

Where Netlify's own pages disagree

I checked the marketing pages against the docs line by line, and they don't fully agree. None of it looks deliberate, and all of it is worth knowing before you quote a figure at someone.

Payment methods, and this one is provably stale. The pricing page FAQ says "Netlify only accepts credit cards unless you have a Netlify Enterprise plan, in which case we do accept payment via ACH or wire transfer." The billing overview docs say "Netlify accepts credit cards, Apple Pay, and Google Pay. Enterprise plan customers can also pay via ACH or wire transfer." Normally you'd shrug at that. But Netlify's changelog dates the Apple Pay and Google Pay addition to 12 August 2026, which means the docs are current and the marketing FAQ simply wasn't updated when the product changed. It was still wrong on 22 August. Trust the docs.

Notification thresholds. Docs FAQ: 50%, 75%, 90%, 100%. Pricing page FAQ: 50%, 75%, 100%. Same vendor, same feature, one missing step. Given the payment-method precedent I'd assume the pricing page is the stale surface here too, but I can't prove it the way I can prove the other one.

Can a free account be charged? The pricing page says "The free plan is always free, with hard monthly limits that cannot be exceeded or incur any costs." I went looking for a contradiction in the legal terms and didn't find one. Section 5 of the Self-Serve Subscription Agreement reads, in full: "For Free Usage Tier Customers, if use exceeds the Services capacity applicable to the Free Usage Tier, Customer will incur and agrees to pay additional fees that reflect actual usage, as such fees are described in the terms of the Free Usage Tier description." Quoted only as far as "actual usage" it sounds like the binding document contradicting the marketing page. Read to the end of the sentence it doesn't: it sets no fee of its own, it defers to the Free tier's published terms — and those terms are the ones saying the limits are hard and cannot incur cost. The two documents agree. Section 6 is the one with teeth, reserving the right to "shut down Free Usage Tier website projects without notice for any reason or no reason."

Database backup retention on Free. The plans doc says 7-day backup retention; the database billing doc's own table says 3 days for Free. Personal and Pro agree across both pages. Only the Free cell disagrees.

Credit pack size. The buy-credit-packs page has a per-band table (Personal 500 for $5, Pro 1,500 for $10) and then an instruction sentence one paragraph below that says "Each credit pack contains 1500 credits for $10.00" with no band named. Personal users following the instructions get the wrong number.

Functions, edge functions and the database

Functions on credit plans are billed by GB-hour, never by invocation. Default memory is 1024 MB and only credit-based Pro and Enterprise can raise it, up to 4096 MB, so a Free-plan function is pinned at 1 GB — which is what makes the compute arithmetic above unusually clean.

Functions setting	Limit
Region	`cmh` (US East, Ohio) — changing it is "available on all Pro and Enterprise plans"
Memory	1024 MB (1024–4096 MB on Credit Pro/Enterprise only)
Synchronous execution	60 seconds
Scheduled execution	30 seconds
Background execution	15 minutes
Buffered request/response payload	6 MB (about 4.5 MB effective for base64 binary, ~30% encoding overhead)
Streamed response payload	20 MB
Background request/response payload	256 KB

Two of those rows are plan-banded and both lock Free out: memory is raisable only on Credit-based Pro and Enterprise, and region is changeable only on Pro and Enterprise. So a Free-plan function is pinned at 1 GB in US East (Ohio), whatever your users' geography. The remaining six — three execution limits and three payload limits — apply to everyone, Free through Enterprise.

Edge functions get 20 MB of code after compression, 512 MB of memory across the deployed set, 50 ms of CPU per request and a 40-second response-header timeout. Invocations are a different story: the edge functions limits page says "the number of invocations allowed per month varies by team plan" and tells you to check your dashboard or ask Support. The number exists; Netlify chooses not to print it. On credit plans that's semi-academic, since edge functions meter through web requests rather than compute, and cached responses don't count at all.

Netlify Database is credit-plans-only, and it's the one place Netlify still publishes hard per-plan gigabyte numbers. Free gets 3 databases, 20 branches each, 48 compute units per billing period, 5 GB written, 5 GB bandwidth and 5 GB storage per database, with a maximum of 1 compute unit and a 5-minute sleep-on-inactivity ceiling. Personal and Pro both move to 100 GB on all three of the GB rows.

There's an open thread here. The database docs say storage "is free until July 1, 2026" and "will be billed no earlier than July 1, 2026, with rates announced in advance." That date is 52 days in the past as I write this, the page is unchanged, and no rate has appeared on it, the pricing page, pricing.md or the plans doc. Storage is currently unbilled. I wouldn't build a 12-month budget on that continuing, and I'm not going to guess when it stops.

The Legacy plans, and where the old numbers come from

If your account predates 4 September 2025 you're on a Legacy plan, and none of the above applies to you. Legacy Free and Starter get 100 GB of bandwidth a month, 300 build minutes, 125k function invocations per site per month, 1M edge function invocations, 100 form submissions per site per month, 1 concurrent build and 500 sites. That's the source of essentially every Netlify free-tier figure circulating online.

Legacy overage behaves differently depending on which meter you blow, which is a nicer design than the credit-plan pause: hit the build limit and your sites keep serving while builds are disabled account-wide; hit any other meter and builds are disabled and all sites are paused until you upgrade.

Netlify has not announced an end-of-life date for Legacy plans. The pricing FAQ still says you can keep your plan with no action required, and I swept the whole August 2026 changelog for a sunset announcement and found nothing. But moving is one-way — "you cannot revert to a Legacy plan from a Credit-based plan. This change is permanent" — and migrating terminates any Analytics subscription immediately with no refund, and moves functions to GB-hour billing where, in Netlify's words, "there is no longer a free tier." Forms get better: free and unlimited instead of 100 per site.

The Open Source plan

Worth a paragraph because it's the only Netlify tier where running out of credits doesn't take your site down. The Open Source plan is 10,000 credits a month, free production deploys, Deploy Previews on every PR, unlimited team members, and explicitly: "Sites stay live even if credits run out." Extra credits are sold at Pro rates.

The qualification bar is real. A license from the Open Source Initiative's approved list, or a Creative Commons license "that includes 'attribution' or places the work in the public domain", plus a Code of Conduct, a link back to Netlify, and a non-commercial project — and Netlify downgrades plans that stop complying, after notice. For a side project, this plus the other free developer tool credits worth having beats squeezing a commercial app into 300 credits.

What Netlify won't tell you

Things I went looking for on Netlify's own pages and could not find, as of 22 August 2026:

A bandwidth allowance in GB for any credit plan — checked the pricing page, pricing.md, how-credits-work, credit-based-pricing-plans and the billing FAQ. A build-minute allowance, which isn't merely unpublished but abolished: "Build minutes are not calculated as their own metric in our Credit-based pricing plans." A function invocation allowance, checked on the same credit pages plus the functions billing doc. An edge function invocation allowance. Enterprise pricing or its credit allotment.

Also: the four higher Pro tier prices on the pricing page, which exist only in the docs. A guaranteed support response time for Free, Personal or Pro — only Enterprise can buy Business Day or Premium Support with response times attached. A quantified fair-use threshold for the free tier, since on credit plans the credit hard limit is the fair-use mechanism. And the price of one pre-launch-toolbar AI audit, a feature that shipped on 19 August 2026 with a changelog note saying audits "consume credits like any other agent run" and no rate anywhere.

A closing note for anyone pulling these numbers with an agent. Netlify publishes an llms.txt index and a Markdown twin of every page, including netlify.com/pricing.md, which is genuinely useful and the reason llms.txt is worth shipping on your own site. One trap: that file's last_updated front-matter field is generated when you fetch it, not when the content changed. Fetching it on 19 August returned 2026-08-19T18:18:51.000Z; fetching it on 22 August returned 2026-08-22T13:11:29.000Z. The prices in between did not move. The field tracks your request, not the content, so don't cite it as evidence of when a price last moved.

PlanetScale Pricing in 2026 — What You Actually Pay

Hirak — Fri, 21 Aug 2026 14:30:01 +0000

A single-node PlanetScale Postgres database costs $5 a month. A high-availability three-node cluster starts at $15, Metal (local NVMe storage, unlimited IOPS) starts at $50, and a Vitess MySQL cluster starts at $39. Those are AWS us-east-1 prices — everything PlanetScale publishes is region-dependent, and every number on this page is us-east-1 unless it says otherwise. There's no free plan. The Hobby tier stopped taking new databases on March 6, 2024 and was retired on April 8, 2024.

Last verified: 16 August 2026.

I re-check this page monthly against PlanetScale's own pricing pages and changelog, not against other people's summaries. Database pricing rots slower than per-token AI pricing, but PlanetScale cut two prices in November 2025 and shipped $50 Metal in December, so "slower" is not "never."

One more thing before the tables. An earlier page on this site described PlanetScale as MySQL-only at $39 a month. It was built on a tool dataset that had gone out of date. PlanetScale flagged it publicly, and they were right. PlanetScale has shipped Postgres since it went GA on September 22, 2025, and $39 is the entry price for one product line, not for PlanetScale. This page is the replacement, checked by hand against planetscale.com/pricing, pricing.md, and the docs on 16 August 2026 — thoroughly enough that I can tell you about a $1 discrepancy in PlanetScale's own numbers further down.

How the billing works

There are no plan tiers on the self-serve side. You sign up, you're on the Base plan, and pricing is resource-based: you pay for the instances you run, the storage you use, and any add-ons, prorated to the millisecond. No contract, no sales call. PlanetScale's own summary of what a bill is made of:

Postgres: cluster size + storage (EBS) + backups + egress + optional dedicated PgBouncer + optional additional replicas
Vitess: cluster size + storage (non-Metal) + optional VTGates + replicas and sharding configuration

A detail I like: PlanetScale publishes a machine-readable pricing page at planetscale.com/pricing.md specifically for AI agents, regenerated on request and stamped with a generation time. It even takes a ?region= query parameter, with 19 region identifiers supported (12 AWS, 7 GCP). It also has a gap you should know about, covered in the discrepancies section below.

Postgres: every cluster size, single node and HA

These are the network-attached (EBS) storage clusters, AWS us-east-1, straight from pricing.md. A single node is one instance, no replicas, no high availability. HA is three nodes — one primary plus two replicas across three availability zones, with a 99.99% SLA. Architecture matters: arm64 is cheaper than x86-64 at most sizes.

SKU	Architecture	vCPU	Memory	Single node	HA (3 nodes)
PS-5	x86-64	1/16	512 MiB	$5	$15
PS-5	arm64	1/16	512 MiB	$5	$15
PS-10	arm64	1/8	1 GiB	$10	$30
PS-10	x86-64	1/8	1 GiB	$13	$39
PS-20	arm64	1/4	2 GiB	$17	$50
PS-20	x86-64	1/4	2 GiB	$20	$59
PS-40	arm64	1/2	4 GiB	$28	$83
PS-40	x86-64	1/2	4 GiB	$33	$99
PS-80	arm64	1	8 GiB	$50	$148
PS-80	x86-64	1	8 GiB	$60	$179
PS-160	arm64	2	16 GiB	$96	$286
PS-160	x86-64	2	16 GiB	$117	$349
PS-320	arm64	4	32 GiB	$190	$570
PS-320	x86-64	4	32 GiB	$233	$699
PS-640	arm64	8	64 GiB	$379	$1,135
PS-640	x86-64	8	64 GiB	$467	$1,399
PS-1280	arm64	16	128 GiB	$755	$2,265
PS-1280	x86-64	16	128 GiB	$933	$2,799
PS-2560	arm64	32	256 GiB	$1,510	$4,529
PS-2560	x86-64	32	256 GiB	$1,867	$5,599

Monthly USD, AWS us-east-1, from pricing.md (fetched 2026-08-16). The $5 single node went live on November 14, 2025; the same announcement cut Postgres development branches from $10 to $5 a month.

Metal: prices are banded three ways

Metal clusters run on locally attached NVMe with unlimited IOPS, and the storage is included in the cluster price. That last part changes the shape of the table: every Metal SKU is sold at several storage capacities, each with its own price. There is no such thing as "the M-10 price" — M-10 on arm64 runs from $50 with 10 GiB of storage up to $180 with 200 GiB. Quoting one row as the SKU's price is exactly the kind of error this page exists to avoid.

Here are the entry configurations (the smallest included storage per SKU), AWS us-east-1, from pricing.md:

SKU	vCPU	Memory	Included storage	arm64	x86-64
M-10	1/8	1 GiB	10 GiB	$50	$60
M-20	1/4	2 GiB	10 GiB	$80	$90
M-40	1/2	4 GiB	10 GiB	$150	$160
M-80	1	8 GiB	100 GiB	$320	$340
M-160	2	16 GiB	100 GiB	$570	$580

All Metal clusters are three-node. The $50 floor is recent: PlanetScale made Metal for Postgres GA at small sizes on December 15, 2025, dropping the minimum from 16 GiB of RAM down to 1 GiB, with storage capacities from 10 GB to 1.2 TB on the new sizes. The pricing.md table runs 95 rows deep and tops out at M-7680 on x86-64 with 61,440 GiB of storage for $47,229 a month. The docs go further still — their largest published Postgres Metal cluster is 192 vCPUs, 1 TB of RAM, and 122,880 GB of storage at $94,429 a month.

Two operational facts that belong next to any Metal price: the storage does not autoscale (you pick a fixed drive up front), and when the disk has 6 GiB or less free, PlanetScale automatically switches it to read-only until you resize.

Vitess: the MySQL side

Vitess is where the old $39 number comes from. It's the entry price of a Vitess cluster — three production nodes (one primary, two replicas) plus roughly 1,440 hours of development branch time per month, which PlanetScale describes as the equivalent of five always-on instances. There is no single-node option for Vitess and no PS-5 tier; on pricing.md, Vitess clusters are x86-64 only.

SKU	vCPU	Memory	Monthly price
PS-10	1/8	1 GiB	$39
PS-20	1/4	2 GiB	$59
PS-40	1/2	4 GiB	$99
PS-80	1	8 GiB	$179
PS-160	2	16 GiB	$349
PS-320	4	32 GiB	$699
PS-400	8	32 GiB	$999
PS-640	8	64 GiB	$1,399
PS-700	16	32 GiB	$1,799
PS-900	16	64 GiB	$1,999
PS-1280	16	128 GiB	$2,799
PS-1400	32	64 GiB	$3,599
PS-1800	32	128 GiB	$3,999
PS-2100	48	96 GiB	$5,399
PS-2560	32	256 GiB	$5,599
PS-2700	48	192 GiB	$5,999
PS-2800	64	128 GiB	$7,199

Three-node Vitess clusters, x86-64, AWS us-east-1, from pricing.md. Vitess Metal exists too, from $609 a month (M-160 with 110 GiB included) up to $23,979 (M-5120 with 14,992 GiB), same region. Horizontal sharding is included with Vitess; for Postgres it's listed as coming soon, under a project PlanetScale calls Neki.

Storage, egress, and backups

Compute is the number on the pricing page. These are the numbers on the invoice. All Postgres figures, us-east-1, from the docs' regional tables:

Line item	Included	Overage, us-east-1
Network-attached storage	10 GB per cluster	$0.125 per GB/month
IOPS (AWS gp3)	3,000	$0.009 per IOPS/month
Throughput (AWS gp3)	125 MiB/s	$0.073 per MiB/s/month
Egress, production branch	100 GB/month	$0.06 per GB
Egress, PS-5 non-HA and dev branches	10 GB/month	$0.06 per GB
Backup storage	2x your disk size	$0.023 per GB/month
Private connection traffic	100 GB/month (production)	$0.01 per GB, both directions

Ingress is free. Backups run automatically every 12 hours at no cost, and overage is billed on the compressed size. The private-connection rate (AWS PrivateLink or GCP Private Service Connect) is flat across regions and replaces the regional egress rate for that traffic — worth knowing if your app servers can sit in the same cloud. And a unit note that trips people up: PlanetScale calculates storage in binary gigabytes, so 1 GB on your bill is 2^30 bytes.

Region matters more than most people budget for. That $0.125 storage rate becomes $0.238 in AWS sa-east-1 and up to $0.312 on GCP; the $0.06 egress rate becomes $0.137 in sa-east-1. If you deploy anywhere other than a big US region, pull the regional tables before you estimate anything. (If you're tallying bandwidth across your whole stack, the Cloudflare pricing breakdown covers the CDN side of that bill.)

The line items people forget

Postgres development branches are $5 a month each, prorated to the millisecond, no replicas. Vitess includes about 1,440 dev-branch hours a month, then bills roughly $0.014 an hour beyond that. An additional production branch is billed as a whole new cluster at its size's price.

Additional Postgres replicas cost about one third of your three-node cluster price — but replicas don't get the 10 GB storage allowance; they pay for the full configured disk. A dedicated PgBouncer (the local one on your primary is free) runs $18 to $551 a month in us-east-1 depending on size, PGB-5 through PGB-160. SSO is a $199 a month add-on on the Base plan.

And one gate that isn't on the pricing page at all: new accounts are capped at PS-160 (and M-320 for Metal) until you've successfully paid an invoice of at least $100. If you were planning to launch straight onto a PS-320, you'll need to contact them first.

Where PlanetScale's own numbers disagree

Here's what checking every figure against every page actually turned up: PlanetScale's pricing surfaces don't fully agree with each other. None of this looks intentional — it looks like documentation drift after three price changes in two months — but if you're budgeting, you should know which number to trust.

First, the $1 drift. Six of the twenty single-node Postgres prices differ between pricing.md and the docs pricing page. All twenty HA rows match exactly; only these single-node rows are off:

SKU (single node)	pricing.md	Docs pricing page
PS-80 arm64	$50	$49
PS-160 arm64	$96	$95
PS-160 x86-64	$117	$116
PS-640 arm64	$379	$378
PS-640 x86-64	$467	$466
PS-2560 x86-64	$1,867	$1,866

I'd trust pricing.md here: it's regenerated on request, timestamped, and it matches the figures the human page serves statically that pricing.md also carries — the $5, $15 and $50 entry prices. The human page's static copy additionally shows the $0.06/GB egress rate and the 10 GB free storage allowance, which pricing.md omits entirely (that gap is the fifth discrepancy below). The full SKU grid on the human page renders client-side, so this comparison covers the headline figures, not all 95 rows. The docs numbers read like a rounding artifact.

Second, and bigger: two docs pages give Postgres storage overage figures 4x apart. The plans doc says network-attached storage beyond 10 GB is "$0.50 per instance per additional 1 GB." The Postgres pricing doc publishes the regional table quoted above, with us-east-1 at $0.125 per GB per month — and its own worked replica example (a PS-10 with 100 GB billed at $33.75 for additional storage) is only consistent with $0.125 across three instances. For Postgres, use the regional table; the $0.50 figure sits in a column shared with Vitess and is most plausibly the Vitess rate. PlanetScale hasn't reconciled the two pages as of 16 August 2026.

Third, the Metal rosters don't match. pricing.md lists 95 Postgres Metal configurations topping out at $47,229; the docs list 92, extending to $94,429 — and neither list contains the other. Rows exist on each side that the other lacks: pricing.md carries arm64 large-storage variants (an M-7680 arm64 row among them) that the docs table doesn't, while the docs price five large configurations pricing.md doesn't, including that $94,429 top end. If you're sizing at the top end, the docs are the only place the biggest machines are priced at all.

Fourth, a small one: the docs' replica-pricing example prices a PS-10 arm64 HA cluster at $34 when the same page's own table (and pricing.md) says $30. That looks like a stale pre-November-cut number left in an example.

Last: pricing.md, the page PlanetScale publishes explicitly for AI agents, contains only cluster prices and the region list. It names storage, backups, and egress in its overview but gives no unit price for any of them. An agent (or a person) sourcing pricing.md alone would miss every non-compute charge on the bill. Ask your AI assistant what PlanetScale costs and there's a fair chance that's exactly what happened.

What isn't published anywhere

Three figures I went looking for and can confirm are not public as of 16 August 2026. The Enterprise and PlanetScale Managed fee — you pay your own AWS or GCP infrastructure bill plus "a percentage of that cost to PlanetScale," and that percentage appears nowhere on the pricing page, pricing.md, or the plans doc. The Business support add-on price — the plans doc says "an additional fee" and points to the support page, which contains no dollar figures. And per-size VTGate prices (VTG-5 through VTG-1280) — every Vitess cluster includes VTGate credits that scale with cluster size, and the docs direct you to the in-app price for anything beyond them; I checked the VTGate scaling doc, both pricing pages, and the Vitess pricing doc.

For all three, the honest answer is: talk to PlanetScale, and don't trust any third-party page that prints a number.

OpenAI API Pricing in 2026 — What You Actually Pay Per Token

Hirak — Wed, 19 Aug 2026 14:30:02 +0000

GPT-5.6 Sol costs $5.00 per million input tokens and $30.00 per million output. Terra is $2.00 in and $12.00 out. Luna, the cheap one, is $0.20 and $1.20. Those are standard-tier prices for prompts up to 272K input tokens — go past that and input doubles while output rises 1.5x, which most pricing write-ups never mention. Two of the three moved on July 30, 2026.

Last verified: 11 August 2026.

I re-check this page monthly against OpenAI's own pricing page and changelog, not against other people's summaries. Per-token pricing is the fastest-rotting number in this industry and a stale table here costs you real money.

The GPT-5.6 pricing ladder

Everything below is the Standard service tier, in dollars per 1M tokens, from developers.openai.com/api/docs/pricing.

One thing you need to know before reading any GPT-5.6 price anywhere: OpenAI's table is split into two context bands. The header tooltips define them precisely — short context is ≤272K input tokens, long context is >272K. Almost every summary you'll find quotes only the short-context half. Here are both.

Short context (≤272K input tokens):

Model	Input	Cached input	Output
gpt-5.6-sol	$5.00	$0.50	$30.00
gpt-5.6-terra	$2.00	$0.20	$12.00
gpt-5.6-luna	$0.20	$0.02	$1.20

Long context (>272K input tokens):

Model	Input	Cached input	Output
gpt-5.6-sol	$10.00	$1.00	$45.00
gpt-5.6-terra	$4.00	$0.40	$18.00
gpt-5.6-luna	$0.40	$0.04	$1.80

The jump is not a rounding detail: input doubles and output goes up 1.5x the moment a request crosses 272K input tokens. If your workload is long documents — codebases, contracts, transcript piles — the long-context column is your real price, and budgeting off the short-context one understates your bill by around 2x on input.

GPT-5.6 Sol, Terra, and Luna API pricing compared

GPT-5.6 Standard-tier, short-context (≤272K input tokens) API pricing for Sol, Terra and Luna — input and output cost in dollars per 1 million tokens, on a log scale. Luna's output price is 25x cheaper than Sol's ($1.20 vs $30.00 per 1M tokens). Verified 10 August 2026 against developers.openai.com/api/docs/pricing.

There's a fourth column on OpenAI's table that most write-ups drop: cache writes, which cost more than a plain input token. Sol writes are $6.25, Terra $2.50, Luna $0.25. That's 1.25x the standard input price, so priming a cache costs you a 25% premium on the first pass in exchange for 90% off every read after it.

The July 30, 2026 changelog entry matters because the two cuts weren't the same size: "Starting July 30, GPT-5.6 Luna costs 80% less, while GPT-5.6 Terra costs 20% less." Luna got the headline. If you sized a budget off a Terra quote from July, you're only 20% off. If you sized one off Luna, your estimate is five times too high, which is the nicer direction to be wrong in.

All three share the same envelope: 1.05M token context window, 128K max output, knowledge cutoff February 16, 2026. So any of them fits your documents — but fitting and costing the same are different things. The 272K band boundary above applies to all three equally, so the choice between models is about cost and quality, while the choice about how much context you send is a separate pricing decision of its own.

Legacy models are still billed at their own rates

This matters more than it sounds. When a vendor retires a model slug, one of two things happens: the request errors, or it silently redirects and bills at the successor's rate. I checked every older row on OpenAI's table against its GPT-5.6 replacement and none of them have been quietly repriced, even the ones already carrying a shutdown date. You pay what the row says.

Model	Input	Cached input	Output
gpt-5	$1.25	$0.125	$10.00
gpt-5-mini	$0.25	$0.025	$2.00
gpt-5-nano	$0.05	$0.005	$0.40
gpt-5-pro	$15.00	—	$120.00
gpt-4.1	$2.00	$0.50	$8.00
gpt-4.1-mini	$0.40	$0.10	$1.60
gpt-4.1-nano	$0.10	$0.025	$0.40
gpt-4o	$2.50	$1.25	$10.00
gpt-4o-mini	$0.15	$0.075	$0.60
gpt-3.5-turbo	$0.50	—	$1.50
o1	$15.00	$7.50	$60.00
o1-pro	$150.00	—	$600.00
o3	$2.00	$0.50	$8.00
o3-pro	$20.00	—	$80.00
o3-mini	$1.10	$0.55	$4.40
o4-mini	$1.10	$0.275	$4.40

o1-pro at $150 input and $600 output per million is still sitting there, roughly thirty times Sol's input price for a model that shuts down in October. Nobody should be sending it traffic. Someone is.

Two other things fall out of this table. gpt-4o's cached input is $1.25, only half its standard input rate rather than the 90% discount the GPT-5.6 rows get, so caching is worth dramatically less on the gpt-4o pair specifically — the gpt-5, gpt-5-mini and gpt-5-nano rows still show the full 90% ratio. And the legacy rows show a dash in the cache-writes column, meaning the write premium is a GPT-5.6-era addition rather than something you were already paying.

Fast mode is Priority Processing with a new name

Do not treat this as a new feature to evaluate. OpenAI's own guide says: "Priority processing was renamed Fast mode on July 30, 2026." Same tier, new label, generally available right now. The old service_tier: "priority" value still works and is an alias for service_tier: "fast", so nothing in your code breaks.

What did change is speed. OpenAI says it "increased the speed at which Fast mode operates for gpt-5.6-sol to make it up to 2.5× faster than Standard processing," with "more consistent latency while keeping pay-as-you-go flexibility."

The price is the interesting part. For the entire GPT-5.6 family, Fast mode is exactly 2x Standard, to the cent — and that holds in both context bands. Short-context Fast prices:

Model	Fast input	Fast cached	Fast output
gpt-5.6-sol	$10.00	$1.00	$60.00
gpt-5.6-terra	$4.00	$0.40	$24.00
gpt-5.6-luna	$0.40	$0.04	$2.40

Above 272K input tokens the same 2x applies to the long-context rates: Sol runs $20.00 in / $90.00 out, Terra $8.00/$36.00, Luna $0.80/$3.60.

Older models get a smaller markup. gpt-4o goes from $2.50 to $4.25 input, which is 1.7x. o3 goes $2.00 to $3.50, or 1.75x. gpt-4o-mini goes $0.15 to $0.25, about 1.67x. If your latency-sensitive path is still on gpt-4o, Fast mode is proportionally cheaper there than it would be on the new family — the sort of asymmetry that quietly changes the shape of a migration plan. (None of the older models publishes a long-context price in any tier — gpt-5.5, gpt-5.5-pro, gpt-5.4 and gpt-5.4-pro are explicitly labelled "(<272K context length)", the rest simply carry no context band at all — so for them the Fast price you see is the whole story.)

Fast mode isn't available on everything. The pricing table's fast tier lists gpt-5.6-sol, terra and luna, then gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.2, gpt-5.1, gpt-5, gpt-5-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, gpt-4o, gpt-4o-2024-05-13, gpt-4o-mini, o3 and o4-mini. No other slugs appear with populated prices.

Batch and Flex: the same 50%, two different trades

Batch is 50% off with a 24-hour completion window, plus what OpenAI calls "a separate pool of significantly higher rate limits." For Sol that's $2.50 input, $0.25 cached, $3.125 cache write, $15.00 output. Terra lands at $1.00/$0.10/$1.25/$6.00 and Luna at $0.10/$0.01/$0.125/$0.60. The long-context band halves the same way — Sol at $5.00 in / $22.50 out above 272K input tokens. Exact halves in both bands, no rounding surprises.

Flex charges the same halved rates for the three GPT-5.6 models — I checked those rows cell by cell, in both bands — but the two tiers are not mirror images: Batch prices 34 model rows where Flex prices 16, so eighteen slugs have a Batch price and no Flex option at all. (The two easy to miss on the Flex list are gpt-5.5-pro and gpt-5.4-pro, both at $15.00 in / $90.00 out — half their standard $30/$180.) And Flex carries a caveat Batch doesn't: OpenAI's guide says plainly that "Flex processing is in beta with limited model availability." What you're buying is different too. Batch trades turnaround for money; Flex trades per-request latency for money and warns about "occasional resource unavailability." So Flex is for synchronous work where you can tolerate slow and can retry, and Batch is for work you can hand over and collect tomorrow. Same bill, very different failure mode.

Prompt caching, and a change that will bite migrations

Caching turns on by itself for any prompt of 1024 tokens or longer. No flag, no opt-in. On the GPT-5.6 family that's a 90% discount on the cached portion, which is the single biggest lever on this whole page if you run long system prompts.

The gotcha is a behaviour change, not a price. OpenAI's caching guide states that GPT-5.6 and later "cache exact prompt prefixes at cache breakpoints," with an implicit breakpoint at the latest user or tool message, and that unlike earlier models it "does not automatically fall back to the longest matching unmarked prefix before that breakpoint." Translated into a bill: a prompt-assembly pattern that was reliably hitting cache on GPT-5 can quietly stop hitting it on Sol, and you find out from your invoice rather than from an error. Watch your cached-token counts for the first week after you switch.

One more line item that's easy to miss: regional processing endpoints carry a 10% uplift for models released on or after March 5, 2026 that are eligible for data residency. Every price above assumes you're not using them.

Usage tiers

Access is gated by cumulative spend, and promotion is automatic — the docs say "as your spend on our API goes up, we automatically graduate you to the next usage tier."

Tier	Qualification	Monthly usage limit
Free	Allowed geography	$100 / month
Tier 1	$5 paid	$100 / month
Tier 2	$50 paid	$500 / month
Tier 3	$100 paid	$1,000 / month
Tier 4	$250 paid	$5,000 / month
Tier 5	$1,000 paid	$200,000 / month

Spend is the only variable on that page. There's no waiting period listed, no account-age criterion, nothing about payment history.

Two things I went looking for and could not find. First, per-model RPM and TPM numbers: I checked the rate-limits guide, the models page and the pricing page on 10 August, and none of them carry a public per-tier RPM/TPM table. The rate-limits guide points you at the models page for "a high-level summary," but the models page's public HTML has no such figures, and the authoritative per-org numbers live behind login at platform.openai.com/settings/organization/limits, which returns 403 without an account. Second, a new-account free credit: I checked the rate-limits guide, the quickstart and the pricing page, and none of them state a dollar grant for new signups. The widely repeated "$5 free credit" isn't on any of those pages, so I'm not printing it as a number. The only "Free" is that top table row, and it's a ceiling, not a gift.

Dated shutdowns you need in your calendar

These are absolute dates from OpenAI's deprecations page. I'm writing them out in full because a page that says "next month" is worthless six weeks later.

Date	What goes away	Replacement
10 August 2026	gpt-5.2-chat-latest, gpt-5.3-chat-latest	gpt-5.6-sol
26 August 2026	Assistants API	Responses API + Conversations API
24 September 2026	Videos API, sora-2, sora-2-pro and all their snapshots	none listed
28 September 2026	gpt-3.5-turbo-instruct, gpt-3.5-turbo-1106, babbage-002, davinci-002	gpt-5.6-terra
23 October 2026	gpt-3.5-turbo (base and 0125), gpt-4 and gpt-4-turbo families, gpt-4.1-nano, gpt-4o-2024-05-13, gpt-image-1, o1, o1-pro, o3-mini, o4-mini	GPT-5.6 family; gpt-image-1 → gpt-image-2
30 November 2026	v1/prompts reusable prompt objects, the Evals dashboard and API (read-only from 31 October), Agent Builder	app code / Agents SDK
1 December 2026	gpt-image-1.5, gpt-image-1-mini, chatgpt-image-latest	gpt-image-2
11 December 2026	gpt-5-2025-08-07, gpt-5-mini-2025-08-07, gpt-5-nano-2025-08-07, gpt-5-pro-2025-10-06, o3-2025-04-16, o3-pro-2025-06-10	Sol / Terra / Luna
20 January 2027	gpt-realtime, gpt-audio, gpt-4o-audio, gpt-4o-realtime and the mini variants	gpt-realtime-2.1 (mini variants → gpt-realtime-2.1-mini), gpt-audio-1.5; gpt-4o-mini-transcribe → its 2025-12-15 snapshot

Mind the gpt-3.5 split: the -instruct and -1106 variants go on 28 September, a month before the rest of the family. If you're on either — both are still individually priced today — the October date everyone quotes is a month late for you.

The two chat-latest snapshots went dark on 10 August 2026, the same day this article was drafted. Notice also that the December wave maps gpt-5-pro and o3-pro onto gpt-5.6-sol with reasoning.mode: pro rather than onto a separate pro model.

Fine-tuning is winding down too. The pricing page says the platform "is no longer accessible to new users," and the deprecations page puts a hard date on the rest: active existing customers can no longer create new fine-tuning jobs after 6 January 2027. Fine-tuned models stay available for inference until their base models are deprecated. If you're already on it, o4-mini fine-tuning is $100.00/hour to train with inference at $4.00/$1.00/$16.00 per 1M, halved to $2.00/$0.50/$8.00 if you opt into data sharing. That data-sharing discount is the only one of its kind on the page, and it applies to fine-tuned inference only, not to regular chat calls.

Everything else on the bill

Embeddings are cheap enough to ignore in most budgets: text-embedding-3-small is $0.02 per 1M, 3-large is $0.13, and ada-002 is $0.10 — which means the old ada model now costs five times the current small one. Moderation via omni-moderation-latest is free, listed literally as "Free" in the input column.

Image generation bills tokens in two streams — and both current models have a shutdown date. gpt-image-1.5 charges $8.00 input, $2.00 cached and $32.00 output per 1M image tokens, plus $5.00/$1.25/$10.00 on the text side. gpt-image-1-mini is $2.50/$0.25/$8.00 for image tokens and $2.00/$0.20 for text input and cached input. Both are removed from the API on 1 December 2026 along with chatgpt-image-latest, replaced by gpt-image-2 — which is already priced on the page at $8.00/$2.00/$30.00 per 1M image tokens ($5.00/$1.25 text). If you're building on image generation in the autumn, build on gpt-image-2 from the start.

Last housekeeping note, and it trips up scripts more than people: platform.openai.com/docs/* now 301-redirects to developers.openai.com/api/docs/*. Old bookmarks resolve fine, so nothing looks broken, but if you've got a scraper or an agent pinned to the old host it's following a redirect it may not be logging. Same class of quiet migration as the retired Grok slugs that keep billing without erroring.

If you're comparing this against what other vendors charge, the free AI API rate limits page covers the zero-dollar end of the market, and whether the Claude API is free does the same for Anthropic.

8 Retired Grok Slugs Still Work — And Bill at grok-4.3 Rates

Hirak — Mon, 17 Aug 2026 14:30:08 +0000

If your code still sends requests to grok-4-1-fast-non-reasoning, grok-3, or six other Grok model IDs, those requests still work. They worked before 15 May 2026 and they have kept working since. Nothing errored, nothing warned, nothing in your logs changed. What changed that day was the bill.

They are being served by grok-4.3 and billed at grok-4.3 prices: $1.25 per 1M input tokens and $2.50 per 1M output.

Last verified: 7 August 2026 against the migration notice and current model docs. Re-checked monthly.

(The company is now SpaceXAI — xAI was absorbed into SpaceX. The docs still say xAI. More on that below.)

The eight slugs

From xAI's model retirement notice, effective 15 May 2026 at 12:00 PM PT:

Retired slug	Now served by
`grok-4-1-fast-reasoning`	`grok-4.3`, `low` reasoning effort
`grok-4-1-fast-non-reasoning`	`grok-4.3`, `none` reasoning effort
`grok-4-fast-reasoning`	`grok-4.3`, `low` reasoning effort
`grok-4-fast-non-reasoning`	`grok-4.3`, `none` reasoning effort
`grok-4-0709`	`grok-4.3`, `low` reasoning effort
`grok-code-fast-1`	`grok-build-0.1`
`grok-3`	`grok-4.3`, `none` reasoning effort
`grok-imagine-image-pro`	`grok-imagine-image-quality`

A note on the name

The company that retired these models was xAI. It isn't called that any more.

SpaceX acquired xAI in a merger that closed 2 February 2026, Musk said in May that xAI would be
dissolved as a separate company, and on 6 July 2026 the rebrand to SpaceXAI was made official
with a new logo and a renamed X account.

The developer surfaces have not caught up. As of 7 August 2026 the API docs still live at
docs.x.ai, still say "the xAI API", and still point support at support@x.ai — no mention of
SpaceX or SpaceXAI anywhere on the retirement notice. The models are still Grok.

So: the retirement was announced by xAI, the entity is now SpaceXAI, and the thing you actually
type into your config didn't change at all. This page says "xAI" where it's quoting xAI's own docs,
because that's what they say.

Why this one is easy to miss

Most deprecations announce themselves. You get a 404, a deprecation header, something in a changelog you eventually read. This one is the opposite, and xAI says so plainly:

After May 15, 2026 at 12:00 PM PT, requests to the retired model slugs above will automatically redirect to grok-4.3. The slugs themselves continue to resolve, so you do not need to change your code to avoid breakage.

That's genuinely considerate engineering — nobody's production traffic fell over. But the same doc adds:

If you continue sending requests to a deprecated slug after May 15, please be aware that you will be billed at grok-4.3 pricing

So the failure mode isn't an outage. It's a bill that changed while every string in your codebase stayed the same. If you set grok-4-1-fast-non-reasoning in an env var eight months ago and haven't looked since, you are on grok-4.3 pricing and your config still says otherwise.

What you actually pay now

Current xAI model pricing, checked 7 August 2026:

Model	Input / 1M	Output / 1M
`grok-4.5` (<200k ctx)	$2.00	$6.00
`grok-4.5` (≥200k ctx)	$4.00	$12.00
`grok-4.3` (<200k ctx)	$1.25	$2.50
`grok-4.3` (≥200k ctx)	$2.50	$5.00
`grok-4.20` reasoning / non-reasoning	$1.25	$2.50
`grok-4.20-multi-agent`	$1.25	$2.50
`grok-build-0.1` (<200k ctx)	$1.00	$2.00

Published Grok API prices under 200k context, and where retired slugs bill

xAI's published under-200k prices per 1M tokens. All eight retired slugs are served by grok-4.3 and bill at its $1.25 / $2.50 — regardless of the model name your config still shows. Verified 7 August 2026 against xAI's own docs.

A note on the old prices. You'll see figures circulating for what the retired fast models used to cost — grok-4-1-fast at $0.20 / $0.50 is the one most often repeated. We're not stating it as fact: xAI no longer publishes pricing for retired models and we couldn't reach an archived copy to confirm it. For your own delta, the only record of what you were actually charged is your xAI billing history either side of 15 May.

You don't need that number to see the problem, though. Everything above is published, and it already shows you're on the mid tier: grok-4.3 at $1.25/$2.50 when grok-build-0.1 sits right there at $1.00/$2.00. You didn't choose that — a redirect did.

What isn't in doubt is the direction. The retired slugs were the cheap, fast tier. grok-4.3 is not the cheap, fast tier.

Check in thirty seconds

grep -rEn 'grok-4-1-fast|grok-4-fast|grok-4-0709|grok-code-fast-1|grok-3\b|grok-imagine-image-pro' \
  --include='*.js'   --include='*.ts'   --include='*.py'  --include='*.go'  \
  --include='*.rb'   --include='*.rs'   --include='*.java' --include='*.json' \
  --include='*.yaml' --include='*.yml'  --include='*.env' --include='*.toml' .

(One --include per extension on purpose. The tidier-looking --include='*.{js,ts,py}' matches nothing at all: the braces are inside quotes so the shell never expands them, and --include doesn't do brace alternation — so it fails silently and looks like a clean bill of health.)

Also check the places code search misses: environment variables in your hosting dashboard, CI secrets, serverless config, and any model name stored in a database or feature flag.

If you get hits, you have a decision rather than an emergency. Requests still succeed. But you should pick the model deliberately instead of inheriting one, and grok-build-0.1 at $1.00/$2.00 is cheaper than grok-4.3 if the work suits it.

The wider lesson

This is the same class of problem as free tiers that quietly shrink — the number you built against stops being the number you're on. Silent redirect is becoming the normal way model providers retire things, because breaking production is worse press than a quiet price change. It's the right call for uptime. It does mean the old assumption — if it still runs, nothing changed — no longer holds for AI APIs.

The practical habit: treat model IDs like dependency versions. Pin them somewhere visible, and re-read the provider's model page on a schedule rather than when something breaks. Nothing will break.

Keep reading

Running Codex CLI or Claude Code on Another Model: What It Actually Costs (2026)

Hirak — Fri, 14 Aug 2026 14:30:02 +0000

Last verified: 6 August 2026; OpenAI, Anthropic and repo facts re-verified 11 August 2026.

Claude Sonnet 5 costs $2 per million input tokens and $10 per million output tokens — as standard pricing now, not an introductory rate. It wasn't supposed to stay that way: the launch price was labelled introductory through 31 August, with a 50% rise to $3/$15 scheduled for 1 September. Anthropic cancelled it. Their pricing page now says it outright: "The $2/$10 per million input/output token pricing for Claude Sonnet 5, announced at launch as introductory pricing through August 31, 2026, is now the standard price. The previously scheduled increase to $3/$15 per million input/output tokens on September 1, 2026 will not occur." If you'd budgeted a September jump into a long agentic coding job, take it back out.

That reversal is the reason this page exists this week. The broader question underneath it is one a lot of people are asking now that opencodex can point Codex CLI or Claude Code at a completely different vendor's model: if the harness is portable, what does each engine actually cost per token?

Output cost per million tokens for models opencodex can route Codex CLI or Claude Code to, verified 6 August 2026

Output price per million tokens (MTok) for every model opencodex can point Codex CLI or Claude Code at, cheapest to most expensive. Claude Sonnet 5 stays at $10 per million output tokens — the 50% rise scheduled for 1 September 2026 was cancelled, and $2/$10 is now the standard price. Log scale; verified 6 August 2026 (Anthropic and OpenAI figures re-verified 11 August) against each vendor's own pricing page.

What opencodex is, and what it isn't

It's a local proxy. Free, MIT-licensed, self-hosted, binds to 127.0.0.1 by default. Latest release is v2.12.0, published 10 August 2026. About 9,300 stars on GitHub when I checked on 11 August.

It does not save you money on tokens. Every provider needs your own key or your own OAuth session. The README is direct about it: "Log in once, skip the API key — OAuth for xAI, Anthropic, and Kimi; or forward codex login, paste a key, or use ${ENV_VAR} references." So opencodex doesn't lower your bill. It changes which meter is running. That distinction is the whole point of the table below, because once you can freely swap the engine under Claude Code, the price per million tokens becomes a decision you make rather than one you inherit.

The provider list it ships with covers OpenAI (ChatGPT login or API key), Anthropic, Google Gemini, SpaceXAI (still branded xAI throughout its docs and opencodex's config), Kimi, Azure OpenAI, and Ollama for local and cloud, plus DeepSeek, Groq, OpenRouter, Together, Fireworks, Cerebras, Mistral, Hugging Face, NVIDIA NIM, MiniMax, Qwen Cloud and SiliconFlow.

Per-token prices, verified 6 August 2026

Every price below came from the vendor's own pricing or docs page on the check date. Rates are per million tokens (MTok).

Model	Input / MTok	Output / MTok	Source
Claude Sonnet 5 (standard — Sept rise cancelled)	$2.00	$10.00	platform.claude.com
Claude Opus 5	$5.00	$25.00	platform.claude.com
Claude Haiku 4.5	$1.00	$5.00	platform.claude.com
gpt-5.6-sol (≤272k input tokens)	$5.00	$30.00	developers.openai.com
gpt-5.6-sol (>272k input tokens)	$10.00	$45.00	developers.openai.com
gpt-5.6-terra (≤272k input tokens)	$2.00	$12.00	developers.openai.com
gpt-5.6-terra (>272k input tokens)	$4.00	$18.00	developers.openai.com
gpt-5.6-luna (≤272k input tokens)	$0.20	$1.20	developers.openai.com
gpt-5.6-luna (>272k input tokens)	$0.40	$1.80	developers.openai.com
Gemini 3.1 Pro Preview (≤200k input tokens)	$2.00	$12.00	ai.google.dev
Gemini 3.1 Pro Preview (>200k input tokens)	$4.00	$18.00	ai.google.dev
Gemini 3.6 Flash	$1.50	$7.50	ai.google.dev
Gemini 3.5 Flash-Lite	$0.30	$2.50	ai.google.dev
Grok 4.5 (<200k input tokens)	$2.00	$6.00	docs.x.ai
Grok 4.5 (≥200k input tokens)	$4.00	$12.00	docs.x.ai
deepseek-v4-pro	$0.435 (cache miss) / $0.003625 (cache hit)	$0.87	api-docs.deepseek.com
deepseek-v4-flash	$0.14 (cache miss) / $0.0028 (cache hit)	$0.28	api-docs.deepseek.com
Ollama, local inference	$0	$0	ollama.com

The spread between the top and bottom of that table is enormous. gpt-5.6-sol output is $30/MTok. deepseek-v4-flash output is $0.28/MTok. That's a factor of over a hundred for the same slot in your Codex config.

The context cliff is the number that should scare you

Three of the four big providers in this table price by prompt length. Gemini 3.1 Pro and Grok 4.5 put the threshold at 200k input tokens; OpenAI puts the GPT-5.6 family's at 272k — the pricing table's own header tooltips define short context as ≤272K input tokens and long context as everything above.

Gemini 3.1 Pro at or under 200k is $2 in, $12 out. Cross the line and it's $4 in, $18 out. Input doubles; output goes up half again. Grok 4.5 is cleaner and worse: $2/$6 below 200k, $4/$12 at or above it — both sides double. OpenAI's cliff has the same shape as Gemini's: gpt-5.6-sol goes from $5/$30 to $10/$45 past 272k, input doubling and output up 1.5x, and Terra and Luna scale identically.

This is precisely the wrong failure mode for agentic coding, because agentic coding is a context-accumulation machine. Claude Code and Codex CLI don't send you a tidy 4k-token prompt. They send file contents, tool call results, diffs, test output, and the entire prior conversation, on every turn. On a small repo you never notice. On a large one, the run starts comfortably under the threshold, grows through a dozen tool calls, and at some point a single extra file read pushes the prompt past 200k. From that turn onward you're on the expensive rate, and nothing in your terminal announces it. You find out on the invoice.

Two practical consequences. If you're routing Claude Code at Gemini 3.1 Pro, Grok 4.5 or the GPT-5.6 family through opencodex on a big codebase, budget for the upper tier, not the headline rate, because that's where a real session ends up. And if you're deliberately keeping context small — narrow file globs, fresh sessions per task, clearing history between subtasks — that discipline is now worth actual money rather than just speed. Our notes on keeping Claude Code's context under control apply directly here.

Anthropic is the odd one out: Claude's published per-token table has no context-length threshold at all, so it's the only pricing in this comparison where the number you budget is the number you pay regardless of prompt size. OpenAI's 272k line is more forgiving than Google's and SpaceXAI's 200k — an agentic session gets another 72k tokens of headroom before the meter jumps — but it's the same trap.

Ollama is the only honest $0

Local Ollama inference costs nothing per token. Not a promotional rate, not a trial credit. You already bought the hardware, and the marginal cost of a token is your electricity bill. For a router like opencodex that's genuinely useful: point the cheap, high-volume work at a local model and reserve the metered API for the parts that need it.

The cloud tier is not free, and it would be dishonest to leave that fuzzy. Ollama's own pricing page lists a free tier at $0 for unlimited public models run on your own hardware, then Pro at $20/mo or $200/yr for "50x more cloud usage than Free" and three concurrent cloud models. Max is $100/mo for ten concurrent cloud models and five times Pro's usage, and it's currently paused for new signups, so you can't buy it today even if you want it. Team is $25/seat/mo with a five-seat minimum.

DeepSeek: publish the flat rate, and one warning

DeepSeek's live pricing page shows a single flat rate per model. deepseek-v4-pro is $0.435/MTok for a cache miss on input, $0.003625/MTok on a cache hit, $0.87/MTok output. deepseek-v4-flash is $0.14, $0.0028, and $0.28 respectively. The cache-hit price is the interesting one for agentic work, where the same system prompt and the same file contents get resent turn after turn.

One line from that same page is worth quoting exactly, because it's the only forward-looking pricing statement DeepSeek makes there: "We plan to raise the overall pricing for DeepSeek API services in the near future, with a significant increase expected." No date, no figures. Treat today's rate as provisional.

What the docs don't tell you

Both major pricing pages moved, and stale links are everywhere. Anthropic's per-token table now lives at platform.claude.com, not the old docs.anthropic.com console path. OpenAI's is at developers.openai.com/api/docs/pricing; the platform.openai.com pricing path is superseded. If a blog post is quoting one of those old URLs, you have no idea how old its numbers are.

Rate limits are the gap. Anthropic's pricing page gestures at Start, Build and Scale usage tiers but does not print the actual requests-per-minute or tokens-per-minute figures on that page, and I'm not going to guess at them. Same story for OpenAI, Google and SpaceXAI as reached through a proxy. If you're planning a high-throughput job, pull each vendor's rate-limit doc directly rather than trusting a number in an article, including this one. There's more on which providers are actually generous in our free AI APIs roundup and on Anthropic's own tiering in is the Claude API free.

The README's "40+ built-in providers" claim I could not confirm. The enumerated list in the README names roughly twenty by name; getting to forty would mean reading ocx init's live provider list, which I didn't do. Take the count as marketing until someone checks it.

Star counts drift fast enough to be useless as a quality signal. The repo read roughly 7,760 earlier that week, 7,770 on 6 August and 9,298 on 11 August. Cite it if you must, but date it.

And the thing nobody says out loud: swapping the model under Claude Code changes the model's behaviour, not just the price. A cheaper engine that needs three attempts at a refactor isn't cheaper. If you're weighing the two harnesses themselves rather than the engines, we covered that in Claude Code vs Codex CLI.

FAQ

Is opencodex free?
Yes. It's MIT-licensed, self-hosted, and runs locally on 127.0.0.1 by default. v2.12.0 shipped on 10 August 2026. You pay each provider directly.

Will Claude Sonnet 5 get more expensive?
No — not on the schedule everyone had in their calendar. The planned 1 September 2026 rise to $3/$15 was cancelled in August 2026; Anthropic's pricing page states the $2/$10 launch price "is now the standard price" and that the increase "will not occur."

Which model is cheapest for running Claude Code?
Local Ollama at $0 per token, if your hardware can handle the model. Among hosted APIs, deepseek-v4-flash at $0.14 in / $0.28 out is the lowest here, with gpt-5.6-luna at $0.20/$1.20 close behind (for prompts up to 272k input tokens — $0.40/$1.80 past it).

A warning that applies well beyond this table: xAI retired grok-4-1-fast-reasoning and grok-4-1-fast-non-reasoning on 15 May 2026, and requests to those slugs are now served by grok-4.3 and billed at grok-4.3's $1.25/$2.50 per million. The name still resolves. Nothing in your terminal tells you the substitution happened. If you are routing through a proxy to a model slug you picked months ago, check it against the vendor's live model list before you check your invoice.

What happens above 200k tokens on Gemini or Grok?
Gemini 3.1 Pro goes from $2/$12 to $4/$18. Grok 4.5 goes from $2/$6 to $4/$12. Long agentic sessions on large repos routinely cross that line.

Does opencodex reduce my token bill?
No. It's a routing layer. It lets you choose a cheaper meter; it doesn't discount any of them.

Is ChatGPT Actually Free in 2026? The Real Limits

Hirak — Wed, 12 Aug 2026 14:30:05 +0000

Yes, ChatGPT is still free in 2026. No card, no trial clock — and as of the week of 10 August, freer than it used to be: OpenAI's help pages now state, in present tense, that Free users have unlimited everyday text chats. If your free account behaved strangely in early August, you weren't imagining it; OpenAI swapped the default model underneath the Free tier mid-week, and for five days its own documentation contradicted itself about what you were getting. This page watched that happen, and the record of it is below.

Last verified: 8 August 2026; rollout status, Free/Go limits and storage figures re-verified 11 August 2026. Every figure below was checked against an OpenAI help page or an OpenAI blog post on one of those dates. Where OpenAI publishes no number, this page says "not published" instead of borrowing one from somebody else's blog.

ChatGPT price ladder, Free to Pro $200/month, verified 8 August 2026

ChatGPT's published monthly price ladder, Free through Pro $200, plus the monthly-vs-annual price of a Standard Business seat. OpenAI describes both Pro tiers as sharing the same core capabilities, with usage allowance as the main difference. Verified 8 August 2026 against OpenAI's own help and product pages.

What changed on 6 August

OpenAI posted on 6 August 2026 that "GPT‑5.6 Luna will become the default model for Free and Go users this week." The help docs say the same thing and add that Free and Go users don't get GPT-5.6 Sol at all; Luna is their default, and Luna is also what powers the Think feature.

The bigger part landed on schedule. The post promised: "Starting next week, they'll also have unlimited text chats and access to a new Think button for harder questions (subject to abuse guardrails)" — and in the week beginning Monday 10 August, OpenAI's help pages flipped to present tense. The Free Tier FAQ now reads: "Free users have unlimited everyday text chats, subject to abuse-prevention safeguards." The GPT-5.6 page says the same for Go, and documents Think as live: "Free and Go users can use Think for harder questions in ChatGPT on the web and in the mobile app." One oddity worth noting: the announcement post itself was never updated — it still promises in future tense what the help pages now document as fact.

Unlimited is OpenAI's word, and the very next sentence in OpenAI's own post walks it back to the part that matters: "Limits will still apply for file uploads, images and other tools." So the honest reading is that plain back-and-forth typing stops being metered, while everything that costs real compute — attaching a PDF, generating an image, running data analysis — stays capped.

OpenAI has published some of those caps already, on a page most write-ups miss: the File Uploads FAQ limits Free users to 3 file uploads per day, against an "up to 80 files every 3 hours" ceiling that applies across plans. Those caps survived the change — the File Uploads FAQ was untouched by the rollout, and the announcement said plainly that "Limits will still apply for file uploads, images and other tools."

One piece is still officially mid-flight: the Luna default. The Availability section states it as fact — "Their default model is GPT-5.6 Luna" — while the Overview on the same page still says Luna "is becoming" the default, and a later section adds that Luna "powers the default ChatGPT experience for Free and Go users as it rolls out". Everything else in this section is present tense on OpenAI's own pages as of 11 August 2026.

The verified price and limit ladder

	Free	Go	Plus	Pro	Business (Standard seat)
Price	$0	$8/mo (US)	$20/mo	$100/mo or $200/mo	$25/user/mo monthly, $20/user/mo annual (min. 2 seats; Premium seat announced at $100/$125, not launched)
What the price buys	—	Localized in some markets	—	$100 = 5x Plus usage; $200 = 20x Plus usage	Per seat; varies by country
Annual billing	—	None	None	None	Yes, $20/user/mo (Standard seat)
Default model	GPT-5.6 Luna (live per docs; vendor still says "as it rolls out")	GPT-5.6 Luna	GPT-5.6 Sol rolling out to eligible paid plans	Same, plus higher usage allowance	GPT-5.5 Instant still listed as the base model
Text chat cap	Unlimited everyday text chats (live per docs, 11 Aug)	Same as Free	Not published	5x / 20x Plus	"Virtually unlimited" on eligible base models
Files per project	5	25	25 or 20 — OpenAI's two pages disagree	40	40
Simultaneous uploads (within Projects)	10	10	10	10	10
File uploads	3 per day	Up to 80 files per 3h	Up to 80 files per 3h	Up to 80 files per 3h	Up to 80 files per 3h
Live voice (all "up to"; OpenAI says limits may change)	Limited GPT-Live-1 mini per rolling 24h	1h Instant + 1h Medium/High + 2h mini	Same as Go	$100: 12h Instant + 12h Medium/High + 24h mini. $200: unlimited GPT-Live-1	1h Instant + 1h Medium/High, then 5 credits/min
Library storage	500 MB	4 GB	20 GB	100 GB	20 GB
Create custom GPTs	No	Yes (all paid plans)	Yes	Yes	Yes
Messages per N hours	Everyday text: unlimited	300 per 3h with Think on; plain chat: unlimited	Not published	Not published	GPT-5.5 Thinking: 3,000/week. GPT-5.5 Pro: 15/month
Images per day	Not published	Not published	Not published	Not published	Not published

Two things in that table are worth more than the rest. The first is that you cannot buy a discount by committing to a year on any individual plan — OpenAI's Pro tiers page states flatly that "Currently, we do not support annual billing or the option to pay for multiple months in advance for ChatGPT Go, Plus, or Pro subscriptions." All three, not just Pro. Business is the only plan here with an annual rate at all, and it's the one aimed at teams. The second is that both Pro tiers "include the same core capabilities. The main difference is usage allowance: Pro $100 unlocks 5x higher usage than Plus, while Pro $200 unlocks 20x usage than Plus." Note OpenAI's word is main, not only — the same page adds that "allowances can differ by Pro tier," and the voice row above is a live example, since unlimited GPT-Live-1 is a $200 thing. Mostly, though, the extra hundred dollars buys headroom rather than capability.

Web search stays off that table because OpenAI only publishes it as a Free-tier capability, and it's a good one: "Search the web and obtain up-to-date information" is listed outright on the Free Tier FAQ. You don't have to pay to get current information out of ChatGPT.

The storage and file numbers are the sharpest real difference between Free and paid for people doing actual work. Library storage runs 500 MB on Free, 4 GB on Go, 20 GB on Plus and Business, 100 GB on Pro — a 200x spread, and the single widest gap between any two rungs of this ladder. Projects allow 5 files per project on Free and 40 on Pro and Business. The 10-file simultaneous upload ceiling applies to everyone including the $200 tier, but note that it's a Projects limit specifically, not a global one.

One caveat on the Plus row, in keeping with the rest of this page: OpenAI publishes two different numbers for it. The Projects help article says 25 files per project; the File Uploads FAQ says "up to 20 files per project" for Plus. Both pages were updated within the last fortnight. I don't know which is current, so the table carries both rather than picking the flattering one.

For five days, OpenAI's own help page contradicted itself — here's the record

This section used to be written in the present tense. It's worth keeping in the past tense, because it explains what free users lived through in early August, and because watching a vendor's documentation disagree with itself is the clearest picture you'll ever get of how these rollouts actually work.

The article at help.openai.com/en/articles/20001354-gpt-56-in-chatgpt says two incompatible things about the Free tier, in two different sections of the same page.

The Overview opens with: "GPT-5.6 Luna is becoming the default model for Free and Go users."

The Availability by ChatGPT plan section agrees: "Free and Go users do not have access to GPT-5.6 Sol. Their default model is GPT-5.6 Luna, which also powers Think." But the line introducing that same section's table — a few lines above it, in the same section — reads: "GPT-5.5 Instant is not shown because it remains the default model."

And the Instant limits section further down still describes Free access the old way: "Free-tier users have limited GPT-5.5 Instant access within a 5-hour window."

So on 8 August the page stated that Luna was becoming the Free default and that GPT-5.5 Instant remained the default model, within a few lines of each other, and then metered the Free tier against Instant in a third place. All three passages were live simultaneously.

By 11 August, OpenAI had resolved it. The page (stamped "Updated: 2 hours ago" when I re-checked) deleted both stale legs — "GPT-5.5 Instant is not shown because it remains the default model" and the "limited GPT-5.5 Instant access within a 5-hour window" sentence are gone — and the Instant-limits section now reads: "Free and Go users have unlimited everyday text chats, subject to abuse-prevention safeguards." What remains is only a tense mix (the Overview still says Luna "is becoming" the default, and the Work/Codex/API section says it powers the experience "as it rolls out", while Availability states flatly that it is the default), plus one orphaned sentence: the Free Tier FAQ still warns that "GPT usage follows your current Free tier model limit" without defining what that limit is now that text chats are unlimited. If your free account hit a wall in early August, this five-day window is almost certainly why — the change was in flight, not your account broken.

The numbers everyone quotes that OpenAI does not publish

Search "ChatGPT free tier limit" and you will get a specific message count per 5 hours and a specific number of images per day, repeated across dozens of pages with total confidence. I'm not printing either one, and here's why.

I could not find either figure on any of OpenAI's current limits pages — the Free Tier FAQ, the GPT-5.6 page, the Plus page or the File Uploads FAQ, all checked again on 11 August 2026. (A 2024 release-note archive does mention two DALL·E 3 images a day for Free, but that model retires on 30 August 2026 and the note describes a product two years gone, so it is not a current limit.) What OpenAI's Free Tier FAQ actually says is: "The following tools can have usage limits separate from the main chat limit: Data analysis with ChatGPT, File and image uploads, Create images in ChatGPT." And elsewhere on the same page: "GPT usage on the Free tier follows the same plan limits as ChatGPT. Advanced functionality, including data analysis, file uploads, and image creation, can have stricter limits than paid plans."

"Can have usage limits" is a deliberate non-answer — and since the August rollout, the main-chat side of the question has dissolved entirely: there is no text-chat cap left to publish.

What makes that interesting is that OpenAI is not generally cagey about numbers. Across its help centre it publishes plenty of hard caps, several of which are in the table above and almost none of which get quoted: 3 file uploads per day on Free, 80 files every 3 hours, 500 MB of Library storage on Free against 100 GB on Pro, 300 messages every three hours for Go users with Think switched on (a figure that changed with the August rollout — it was 10 per 5 hours days earlier), 3,000 GPT-5.5 Thinking requests a week on Business. Those are specific, and they're published.

So the silence is narrow and it's deliberate. The two figures OpenAI declines to state are exactly the two the whole internet quotes: how many messages a free user gets per 5 hours, and how many images per day. Those move with load, which is the obvious reason not to commit to them in writing. A community number that was true for someone in March, in one region, on one account, is not a published limit — and quoting it as one is how bad reference pages get built. We took the same approach when we checked whether the Claude API is free: several vendors have quietly stopped publishing free-tier numbers, and the correct response is to say so.

A few more things I deliberately left out of the table because I couldn't verify them:

Deep Research on Free. OpenAI's FAQ confirms allowances "vary by plan" and points you at an in-product counter. It doesn't state a Free-tier number, so I don't have one. The one useful detail it does give applies to everyone: where a plan has a fixed monthly allowance, "it resets every 30 days from the date of your first use." Not calendar month. If you burned your allowance on the 20th, that's your reset date now, and it drifts.

Connectors and memory on Free. No primary page I could fetch states the Free-tier scope for either. Unconfirmed, so unstated.

Ads. Two OpenAI pages disagree on tense. The ChatGPT Go announcement says OpenAI plans to test ads in the free tier and Go in the US "soon," which reads as pending. The Free Tier FAQ says ads "may appear in the Free tier in certain countries," which reads as already possible somewhere. Whether ads are live for you today is not answerable from OpenAI's published material, and I'm not picking a side.

Two things that are simply gone

People still ask about both, so: Sora is not part of the free ChatGPT product, or the paid one. OpenAI's own page says "The Sora web and app experiences were discontinued on April 26, 2026," with the API following on 24 September 2026. And the DALL·E GPT inside ChatGPT is being retired on 30 August 2026 — the release note advises downloading anything you want to keep before then. That's three weeks from this update, so if you have image history sitting in that GPT, go get it.

The context window caveat

GPT-5.6 Luna's documented context window is 128K, with GPT-5.6 Terra also at 128K and GPT-5.6 Sol at 272K. Important qualifier: that figure is published on the ChatGPT Business plan's models-and-limits page, not on any Free-tier page. Luna is the Free/Go default, so 128K is the model's window — but OpenAI does not state anywhere I could find that the Free plan is entitled to the full 128K in practice. Treat it as a model-level number, not a free-plan guarantee.

When paying actually makes sense

If you're hitting the wall on Free, the one genuinely useful mechanic is that you don't wait it out: OpenAI's FAQ says "if you reach a rate limit on your Free tier account, your usage rates will reset when you update your account to a Plus plan, a Pro plan, or a Business plan." Upgrade mid-block and you're unblocked immediately.

Beyond that the ladder is unusually clean for once. Go at $8 buys you the GPT creator, 25 files per project instead of 5, 4 GB of Library storage instead of 500 MB, and real voice time. Plus at $20 buys the same voice allowance as Go and a Projects cap that OpenAI states as either the same or slightly lower — so the honest case for Plus over Go is model access, usage headroom, and 20 GB of storage against Go's 4 GB. Pro's two rungs share the same core capabilities and differ mainly in allowance, with 100 GB of storage and unlimited live voice at $200. A Standard Business seat at $20 billed annually lands on exactly the same monthly price as Plus with the same 20 GB, which is worth knowing if there are two of you and you assumed the team plan carried a premium. Two caveats if you're buying seats. Business has a two-seat minimum, so $20 a head means $40 a month, not $20. And a second seat type is on the way: OpenAI's Business page now announces that "Premium seats cost $100 per user per month when billed annually, or $125 per user per month when billed monthly," including "5x more usage than Standard seats, no 5-hour usage limit, and the flexibility to mix, assign, and reassign seat types." It has not launched — there is a waitlist, open "before August 20" — so the $25/$20 figures above are Standard-seat prices and remain current. Note the detail hiding in that announcement. Premium promising "no 5-hour usage limit" only means something if Standard seats have one — and OpenAI's Premium seats announcement says it twice more, that Premium "removes the five-hour usage limit" and, in its feature list, "No five-hour usage limit." So across two OpenAI pages the five-hour window is confirmed to exist for Standard seats, and on neither one is it given a number. That is the single clearest example on this page of the pattern I keep running into: OpenAI will confirm a limit exists while declining to say what it is.

For most people asking whether ChatGPT is free, the answer they actually want is "free enough" — and since the August change, for text-only chatting, it plainly is. If your use case is programmatic rather than conversational, that's a different question with a different answer; our free AI APIs roundup covers the metered side, and the tools I actually use daily piece covers what earns a subscription.

The rollout landed, the contradiction resolved, and this page was re-verified against the updated pages on 11 August 2026. The next scheduled re-check is the monthly refresh — sooner if the orphaned "Free tier model limit" sentence gets a definition.

GEO vs SEO: How to Rank in AI Search Engines (2026)

Hirak — Mon, 10 Aug 2026 14:30:00 +0000

SEO got you ranked on Google. GEO gets you cited by AI. In 2026, you need both — and they don't work the same way.

Here's the complete guide to Generative Engine Optimization: what it is, why it matters, and exactly how to do it.

What Is GEO?

GEO (Generative Engine Optimization) is the practice of optimizing your content so AI-powered search engines — ChatGPT, Perplexity, Google AI Overviews, Claude — find it, understand it, and cite it in their responses.

When someone asks Perplexity "what's the best AI code editor in 2026?", Perplexity searches the web, reads multiple sources, synthesizes an answer, and cites its sources. GEO is what determines whether your article becomes one of those cited sources.

GEO vs SEO: What's Different?

Factor	Traditional SEO	GEO
Goal	Rank #1 on Google SERP	Get cited in AI-generated answers
Evaluation	Google's algorithm (links, keywords, authority)	AI model's judgment (relevance, clarity, authority)
Content format	Optimized for scanners (headings, bold, images)	Optimized for extraction (stats, quotes, structured data)
Keywords	Exact match and semantic keywords	Natural language, question-based
Links	Backlinks from high-authority domains	Citations from trusted, recent sources
Freshness	Updated content ranks better	Recent content with dates is strongly preferred
Trust signals	Domain authority, HTTPS, backlinks	Author expertise, first-person experience, citations

The key insight: SEO optimizes for ranking algorithms. GEO optimizes for language models. They overlap but they're not identical.

How AI Search Engines Decide What to Cite

I've studied the citation patterns of Perplexity, ChatGPT Search, and Google AI Overviews. Here's what they consistently favor:

1. Specific Numbers and Statistics

AI models love extractable facts. Compare:

Weak: "AI code editors are popular among developers."
Strong: "47% of professional developers use an AI code editor daily, up from 12% in 2024 (StackOverflow Developer Survey 2026)."

The second version is citable. The first is filler.

2. First-Person Authority

AI models weight first-hand experience. "I tested all 8 AI code editors" is more citable than "there are many AI code editors available." E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) matters even more for AI citations than for Google rankings.

3. Direct Answers to Questions

Structure your content around the exact questions people ask AI:

"What is the best AI code editor?"
"How much does Cursor cost?"
"Is Copilot worth it in 2026?"

Put the answer in the first sentence after the heading. AI models extract from the first 1-2 sentences of a section more than anywhere else.

4. Structured Comparisons

Tables, bullet lists, and comparison formats are extracted at a much higher rate than prose paragraphs. AI models can parse tables directly and use them in responses.

5. Recency Signals

AI search tools heavily prefer recent content. Include:

Publication dates in your content
"Updated April 2026" notices
Year in your title and headings
References to current events or recent data

The GEO Playbook: 10 Tactics That Work

Tactic 1: Add llms.txt to Your Site

llms.txt is a markdown file at your domain root that tells AI models what your site is about, what it offers, and how to cite it. Think robots.txt for AI.

This is the single highest-ROI GEO action you can take. Thirty minutes of work, permanent benefit.

Tactic 2: Use Question-Based Headings

Instead of:

## AI Code Editor Features

Write:

## What Are the Best AI Code Editor Features in 2026?

AI models match user questions to content headings. Question-based headings get extracted more often.

Tactic 3: Lead Every Section with the Answer

The "inverted pyramid" from journalism applies perfectly to GEO. Put the most important information first:

Bad:

There are many factors to consider when choosing an AI code editor. Let me walk you through the history of IDE development...

Good:

Cursor is the best AI code editor for most developers in 2026. It offers the fastest autocomplete, reliable multi-file editing, and costs $20/month.

AI models extract from the first 1-2 sentences. Don't bury the answer.

Tactic 4: Include Comparison Tables

Every article comparing options should have a table. AI models extract table data directly and use it in comparative responses.

Include: name, price, key differentiator, best-for use case, and a rating or recommendation.

Tactic 5: Cite Your Sources

AI models trust content that cites external sources. Link to studies, documentation, official pricing pages, and data sources. Content with citations is perceived as more authoritative than unsourced claims.

Tactic 6: Add Schema Markup (JSON-LD)

Structured data helps AI models understand your page type (article, product, FAQ, how-to) and extract specific fields. At minimum, add:

Article schema with author, datePublished, dateModified
FAQPage schema for question-heavy content
HowTo schema for tutorial content
Product schema for product pages with pricing

Tactic 7: Write for Extraction, Not Just Reading

Every paragraph should contain at least one extractable fact, recommendation, or insight. Fluff paragraphs ("in today's fast-paced world...") are skipped by AI models entirely.

Test: Can an AI extract a useful standalone quote from this paragraph? If not, rewrite it.

Tactic 8: Include Author Credentials

Add an author bio that establishes expertise. "Written by a developer who shipped 12 apps using AI tools" is a trust signal AI models weight when deciding which source to cite.

Tactic 9: Update Regularly and Show It

AI models check dates. A post from 2024 about "best tools in 2026" gets deprioritized. Add updatedDate to your posts and display it visibly. Monthly updates to key articles keep them competitive.

Tactic 10: Cover Adjacent Questions

When someone asks about "best AI code editor," they might also ask about pricing, comparisons, and alternatives. Cover these in your article. AI models prefer comprehensive sources over narrow ones because they can extract more answers from a single citation.

How to Track Your GEO Performance

Manual Testing

Ask AI search engines questions related to your content. Search Perplexity, ChatGPT, and Google AI Overviews for your target queries. See if you're cited.

Do this weekly for your top 10 target queries.

Tools

Perplexity Analytics — Check if your domain appears in Perplexity citations
Google Search Console — AI Overview clicks show in the Performance report
Semrush / Ahrefs — Both added AI citation tracking in 2026

Metrics That Matter

Citation rate: What percentage of relevant AI queries cite your content?
Citation position: Are you the first source cited or the fifth?
Click-through from citations: Do people click your link in the AI response?

SEO Is Not Dead

To be clear: traditional SEO still matters. Google still drives the majority of web traffic. Backlinks, page speed, mobile optimization, and keyword targeting still work.

GEO is additive, not a replacement. The smartest content strategy in 2026:

Write content that ranks on Google (SEO)
Structure it so AI models cite it (GEO)
Add llms.txt for site-level AI optimization
Update regularly to maintain both

The good news: most GEO tactics also improve your SEO. Clear headings, structured data, cited sources, and fresh content help you rank better on Google too.

What to Do This Week

Create your llms.txt file. 30 minutes, massive long-term impact.
Audit your top 5 articles. Do they have question-based headings? Comparison tables? First-sentence answers? Statistics?
Add schema markup to your most important pages.
Test your target queries on Perplexity and ChatGPT. See who's currently getting cited.
Update dates on all your key content. Add updatedDate if you don't have one.

AI search is not the future — it's the present. Every week you wait, competitors are getting cited instead of you.

Keep reading:

Seline Review: A Privacy-First Google Analytics Alternative Worth Watching (2026)

Hirak — Fri, 07 Aug 2026 14:30:03 +0000

Last updated: July 21, 2026.

Most teams don't leave Google Analytics because they found something dramatically better. They leave because GA4 got confusing, the cookie banner got embarrassing, and legal started asking questions about where the data lives. That's the gap a whole category of privacy-first analytics tools grew into, and Seline is one of the newer names in it.

I spent time with it to see whether it's a real option or just another Plausible clone with a different logo. Short version: it's genuinely its own thing, with one caveat worth knowing before you get attached.

What Seline actually is

Seline is a cloud-hosted, cookieless web and product analytics platform. It came out of a small bootstrapped team in Warsaw in 2024, and the whole pitch is built around two ideas: keep the tracking script tiny, and keep the data private and in the EU.

The script is about 2kb. For comparison, Google's tag is heavy enough that people build whole performance budgets around deferring it. Seline's claim is roughly 23x lighter, and while I wouldn't treat any vendor's own number as gospel, the practical effect is real: you add one HTML snippet and you're not paying for it in Lighthouse points. Setup is a copy-paste, with documented paths for Next.js, WordPress, Webflow, Framer, Shopify, Ghost, and Carrd.

Privacy is the other half. There are no cookies. Instead of storing an identifier on the visitor's device, Seline uses non-reversible hashing off signals like IP, browser, and device to recognize sessions. Nothing lives client-side, which is why sites using it generally skip the consent banner. Data sits on servers in Germany, the company is EU-based, and they're explicit that they don't sell or share it. If your reason for leaving GA was a compliance conversation, this is the part that matters.

It goes further than "pretty pageview charts"

This is where Seline separates itself from the minimalist crowd. Plausible and Fathom are deliberately simple: traffic, sources, top pages, done. Seline covers that baseline (page views, referrers, countries, devices, UTMs) but then keeps going into territory that's usually a separate product.

You get custom events for the things that actually matter, like button clicks, form submissions, and signups. You get conversion funnels to see where people drop. You get individual visitor journeys, so you can follow a single session through the site instead of only reading aggregates. There are user profiles with custom attributes, which starts to look more like a lightweight product-analytics tool than a website counter.

The one that caught my attention is revenue tracking. Seline integrates with Stripe, Polar, and Shopify, so you can tie traffic and events to actual money. For a small SaaS or store, being able to answer "which source brought revenue, not just clicks" inside your analytics tool, without wiring up a separate pipeline, is a genuinely useful thing to have.

The AI features, with the hype dialed down

Seline leans into AI, and I'll give it a fair but skeptical read. There's an AI chat assistant that lets you ask questions of your data in plain language and have it generate CSVs, and there's an MCP interface, which means you can point an AI agent at your analytics directly. It also flags referrers from AI tools like ChatGPT, Perplexity, and Claude, which is quietly one of the more forward-looking touches given how much discovery is shifting toward AI answers.

Is any of this going to replace an analyst? No. But "ask a question, get a chart or a CSV" removes a real friction point for founders who know what they want to know but not which dashboard to click. Treat it as a convenience layer, not magic, and it holds up.

Rounding out the list: a live globe view of current visitors, bot detection, and filtering by custom attributes, UTMs, dates, and engagement. The globe is eye candy. The filtering is the part you'll use daily.

The catch: there's no free plan

Now the part you need to know before you get attached. Seline has no free tier. It's a single Pro plan, billed monthly or annually, with annual giving you two months free, and it's scoped around 100,000 page views a month. The team is candid about why: they're bootstrapped and run entirely on subscriber fees, not on a free plan subsidized by selling data. I actually respect the honesty of that positioning, and it's consistent with the privacy story. But it does mean Seline isn't the tool for a hobby project or a portfolio site where you just want a free counter.

I'm not going to quote a dollar figure here because these things change and the price loads dynamically on their site. Check the pricing page for the current number before you budget anything off this post. What matters structurally is the model: one plan, no artificially locked features, pay to play.

Who it's for, and who it isn't

Seline fits you well if you're a small-to-mid SaaS, an indie product, or a store that wants privacy-first analytics but has outgrown "just pageviews." The revenue tracking and event funnels are the draw, and the EU hosting closes the compliance question. If you've been running Plausible and keep wishing it did just a bit more on the product side, this is the natural step up.

It's a weaker fit if you need a free tool, if you specifically want self-hosting (Seline is cloud-only, so an open-source option like Umami serves that better), or if your analytics depend on Google's ad-network integrations. Those are real constraints, not dealbreakers for most people, but know them going in.

Bottom line

Seline is a well-scoped, privacy-first analytics tool that does more than the minimalist crowd without turning into an enterprise monster. The 2kb script and EU hosting handle the two reasons people leave GA4, and the revenue tracking plus AI querying give it a reason to exist beyond "Plausible but different." The no-free-plan decision is the one thing that will filter people out, and it should: this is a paid tool for teams that treat analytics as worth paying for.

If that's you, it's worth a look. Start with your highest-traffic site, wire up one revenue integration, and see if the "money, not just clicks" view changes how you read your traffic. That's the test that tells you whether Seline earns its keep.

Disclosure: This is a sponsored review. Seline paid for a dedicated write-up on stackwrite.com. We only accept sponsorships for tools we're willing to cover honestly, the opinions and the caveats here are our own, and outbound links to the sponsor are marked as sponsored.

How to Count Down to a Specific Time on iPhone (Not Just Days) in 2026

Hirak — Wed, 05 Aug 2026 14:30:02 +0000

You set up an iPhone reminder for your flight, your wedding, a product launch — and what you actually want is a visible countdown ticking down to that moment. Not a notification five minutes before. Not a "tomorrow" badge. A real countdown: days, hours, minutes, ticking.

Turns out iOS doesn't ship with anything that does this. Three Apple apps almost do it, and each one falls short in a frustrating way. Here's why, and how to set up an actual iPhone countdown to a specific time in about a minute.

Why Apple's built-in apps don't do this

Calendar is the obvious place to look. You create an event for "Flight to Tokyo, August 15, 2:30 PM" and Calendar shows it on the date grid. It'll even pop a notification when it's close. What it doesn't do is show you a live countdown anywhere — no widget, no Lock Screen view, no "2 days, 4 hours, 17 minutes" anywhere on your phone.

Clock app → Timer counts down. But only from a duration. Set it to 23 hours 59 minutes (the max) and that's the longest countdown it'll do. Close the app, and it keeps running, sure. But it can't count to a specific date. If your event is six weeks away, the Timer is useless.

Reminders is even worse for this. It's a checklist with optional notifications. No countdown view at all.

So the gap is real: Apple has timers (count from a duration) and event reminders (notify near the date), but no countdown to a specific moment. That's a third-party problem.

What you actually need from a countdown app

If you're going to install one app for this, these are the features that matter:

Event date AND time — not just the date. A countdown to "August 15" rounds to midnight, which is wrong if your flight is at 2:30 PM.
Live updates — the countdown should refresh on its own, not just show "in 3 days" forever. Ideally ticking down to the second.
Lock Screen widget — so you don't have to open the app to see it.
Dynamic Island support (iPhone 14 Pro and newer) — for the live ticking experience.
Widget on the Home Screen — at least medium-size, so the time fits.

Bonus features that some apps have and most don't:

Apple Watch app so the countdown is on your wrist
Multiple events visible at once (most apps make you switch)
Counting up for past events (anniversaries, recovery milestones)

Most of the App Store's countdown apps handle #1 and #2 but skip Dynamic Island or charge for it. A few do the whole stack.

The apps that do it properly

I've tested a stack of these for the best countdown apps for iPhone in 2026 roundup. For "countdown to a specific hour and minute, ticking live, visible everywhere" — three are worth installing.

DayDrop

My own app — I built it, so treat this entry as the developer describing what it does rather than an
independent pick. Ticks down to the exact second on the Lock Screen and in the Dynamic Island. Apple Watch app too, with the background image synced from your phone. Free tier supports unlimited countdowns, Small and Medium widgets and photo backgrounds. Paid unlocks the Live Activity ring, Dynamic Island, multi-event widget, exact-time countdown and AI backgrounds — $1.99/month, $12.99/year (one month free), or $24.99 once. Requires iOS 18.0 or later. (Verified 6 August 2026.)

The thing that sells it for this specific use case is the Live Activity Progress Ring. You see the seconds tick down on your Lock Screen, and the Dynamic Island shows the same countdown when the screen's on. For a flight or a wedding, you're glancing at your phone constantly, and the answer is always one glance away.

Get DayDrop on the App Store

Countdown+

Solid widgets, supports specific-time events, no Dynamic Island. Free, ad-supported. Good if you don't have a Pro model iPhone and only need a Lock Screen widget.

Widgetsmith

Not a dedicated countdown app, but the "Countdown to Date" widget supports time-of-day if you tap into the custom settings. Limited customization on the free tier and no live tick — it updates roughly every 15 minutes. Works if you already have Widgetsmith installed for other widgets.

There are a dozen others. Most of them are date-only or stop updating once they're more than 24 hours away.

Setting it up — the short version

Pick an app from above. I'll walk through DayDrop because it's the one that does the full stack; the principle is the same for the others.

Open the app, tap + to add an event.
Type a title — "Flight to Tokyo" — and toggle on Specific time. Set the date and the exact hour and minute.
Pick a category if you want it grouped (Travel, Work, Birthday, etc.).
Tap Save. The countdown is now live.

That gets you the countdown inside the app. To make it visible without opening the app, you have two paths:

Path A — Lock Screen widget

Long-press your Lock Screen → Customize → Lock Screen
Tap the widget area below the clock → Add Widgets
Find the countdown app, pick the inline or circular widget, tap it
It now sits on your Lock Screen showing the live count

Path B — Home Screen widget + Dynamic Island

Long-press an empty part of your Home Screen → tap + in the corner
Find the countdown app and pick a widget size (medium fits the time best)
Place it and pin your event
For Dynamic Island, open the event inside the app and toggle Live Activity on (DayDrop calls this "Pin to Dynamic Island"). The countdown will now show in the Dynamic Island for the next 8 hours by default, and you can extend it.

If you set up the Live Activity, the countdown ticks live in real time when the Lock Screen or Dynamic Island is visible. You don't open anything. You just glance and it's there.

Edge cases that trip people up

Time zones. If you're counting down to a flight in another time zone, decide whether the countdown should be based on your local time or the destination. Most apps store events in your device's local time, which is usually what you want — your departure is in your local clock. But for a wedding or product launch in another city, you might want it the other way. DayDrop and Countdown+ both let you set per-event time zones; Widgetsmith doesn't.

Past events. When the countdown hits zero, what happens? Better apps switch to counting up so you can use the same event for "days since." Cheaper ones just show "0 days" forever or hide the widget.

Recurring events. Birthdays, anniversaries, annual deadlines. If you want the countdown to roll over to next year automatically, check that the app supports a recurring/annual flag before you build out a list of 30 birthdays. DayDrop's birthday import handles this; some others require manually editing each one.

Battery. Live Activities are designed to be efficient — they sip battery, they don't drain it. If a Live Activity is killing your battery, the app is doing something wrong, not Apple. Live Activities have a hard 12-hour ceiling on the Lock Screen anyway, after which they fall back to a static notification.

When you don't need an app at all

Honestly: if your event is within 24 hours and you just need "wake me at 6 AM tomorrow," use the Clock app's Alarm. Or for "remind me an hour before the meeting," use the Calendar event's default alert. The countdown app is for events that are days, weeks, or months out and where you want it on your face the whole time.

The bottom line

iOS doesn't ship with a real countdown to a specific moment. That's the gap, and it's been the gap for the better part of a decade. A handful of third-party apps fill it well — DayDrop is the most complete for live ticking across the Lock Screen, Dynamic Island, and Apple Watch. Countdown+ is fine if you don't have a Pro phone. Widgetsmith works if you've already paid for it.

Set one of them up once and the wedding, the vacation, the launch — they all live one glance away from now until they happen.

If you want the full breakdown of the apps in this space, the countdown apps for iPhone roundup is the deeper version of this post, and the Dynamic Island countdown guide goes into the Live Activity setup in more detail.

Claude Code vs Codex CLI: Which Terminal Coding Agent Wins in 2026?

Hirak — Mon, 03 Aug 2026 14:30:02 +0000

Two terminal coding agents, one decision. Claude Code from Anthropic, Codex CLI from OpenAI. If you just want the answer: go with Claude Code if you care about the richest tooling ecosystem and strong multi-file refactoring; go with Codex CLI if you're already paying OpenAI and want a single bill, or you want an open-source agent you can read and fork. Both do the core job well, so this is mostly about which world you'd rather live in.

A note on scope first. Both of these run in your terminal, read your codebase, edit files, and run commands. Neither is an editor plugin. If what you actually want is AI inside VS Code, that's a different question, and we cover it in the Claude Code vs Cursor vs Copilot comparison. This post is the two big terminal agents, head to head.

The short version

Pick Claude Code if you do heavy multi-file refactors and want the most tooling around the agent. Pick Codex CLI if you're already on a ChatGPT or OpenAI API plan and don't want a second AI subscription, or if you specifically want an open-source tool you can audit or self-host. If you're a team that runs hooks, MCP servers, and subagent workflows, that's Claude Code territory. And if you're just trying a terminal agent for the first time on a side project, honestly, start with whichever ecosystem you already pay for — both are good enough to learn on.

Everything below is "as of 2026." Both tools ship updates almost weekly, so confirm pricing, rate limits, and model availability on the official docs before you commit.

What each one actually is

Claude Code is Anthropic's agentic CLI. You run it in your terminal inside a repo, describe a task, and it plans, edits files across the project, runs your build and tests, and iterates until it's done. It runs on Claude models, and you authenticate either with a Claude Pro or Max subscription or an Anthropic API key.

What sets it apart in 2026 is everything around it. MCP support, so you can connect Model Context Protocol servers for databases, browsers, issue trackers, docs, whatever. Subagents, so you can spin up scoped helpers and keep the main thread focused. Hooks, so you can run your own shell commands at lifecycle points — before edits, after tool calls, on stop. Slash commands you check into the repo and share with the team. There's also a sizable community building configs and plugins on top of all that. If you've never gone past the basics, our Claude Code tips and tricks post is a decent next stop. (New to MCP entirely? Start with how MCP servers work.)

Codex CLI is OpenAI's open-source terminal coding agent. It runs locally, reads and edits your repo, and runs commands — the same core loop. It runs on OpenAI's coding-focused models, and you authenticate with an OpenAI API key or a ChatGPT plan that includes Codex usage.

The headline difference is right there in the description: it's open source. You can read exactly what it does, look at how it sandboxes commands, file issues against it, and fork it if you want a custom build. It's also a lighter footprint — fewer moving parts than Claude Code's full plugin/hook/subagent stack. The flip side is that the ecosystem around it is younger. You won't find the same pile of community MCP integrations and shared workflows yet.

(Worth saying: OpenAI has used the name "Codex" for a few different things over the years — the old code model, a cloud agent, the CLI. This post is about the command-line tool specifically.)

Side by side

	Claude Code	Codex CLI
Pricing	Claude Pro / Max subscription, or Anthropic API key (usage-based)	OpenAI API key (usage-based), or a ChatGPT plan that includes Codex
Models	Claude family	OpenAI's coding models
Open source?	No, closed client	Yes, you can read and fork it
IDE integration	Terminal-first; companion editor integrations exist	Terminal-first
Extensibility	First-class MCP, subagents, hooks, slash commands, plugins	More minimal, growing — check the repo for the current state
Sandboxing / approval	Permission prompts before edits and commands; configurable allow-lists	Approval/sandbox modes for read-only, edit, and full-auto runs
Multi-file editing	Widely praised for whole-codebase refactors	Solid multi-file edits; capable agent loop
Ecosystem maturity	More mature; big community, lots of tooling	Younger but moving fast, backed by OpenAI
Best for	Complex refactors, team workflows, MCP-heavy setups	OpenAI-ecosystem devs, one-bill simplicity, auditability

Treat that as a starting point, not gospel. Both products change fast, and the rows most likely to move are pricing, model names, and extensibility.

Where Claude Code pulls ahead

Ecosystem depth, mainly. This is the biggest gap right now. MCP servers, subagents, hooks, slash commands — Claude Code has all of it, and there's a real community building on top. If your workflow involves wiring an agent into your database, your issue tracker, your docs, and your CI, Claude Code arrives with more batteries included.

Multi-file refactors are the other one. Across developer chatter in 2026, Claude Code is the tool people reach for when a change touches a model, a service, three routes, and a UI component all at once. It tends to read project structure, test patterns, and naming conventions well, and apply changes coherently across the tree. It's the same strength that lands it near the top of broader roundups like our best AI code editors comparison.

And the everyday ergonomics are smooth — the permission model, the diff display, session handling, project-checked-in commands. It feels like a product that's been through a lot of iterations, because it has.

What you give up: you're on Anthropic's pricing and subscription model. If you're not already paying for Claude Pro or Max, that's a new line item. And it's closed source, so you can't inspect or fork the client.

Where Codex CLI pulls ahead

It's open source, and for some people that settles it. You can read the code, see how it sandboxes commands, audit it for a security review, contribute fixes, fork it for an internal build. For teams with compliance requirements — or developers who just don't love a black box running loose in their repo — that matters a lot.

It's also one account, one bill. If you're already paying OpenAI for ChatGPT or running on an OpenAI API key, Codex CLI slots in with no new billing relationship. For a lot of people that's the whole decision: they don't want a second AI subscription, full stop.

And it's lighter. Fewer concepts to learn — no hooks, subagents, or plugin layer to wrap your head around. You point it at a repo and go. For a side project or a quick task, that simplicity is a feature.

What you give up: the younger ecosystem. Fewer community MCP integrations, fewer shared workflows, less of a "here's the config everyone uses" culture, at least for now. And it's only as good as OpenAI's coding models, which are strong, but you're betting on their roadmap.

If you want to widen the field beyond these two, Aider is another terminal-leaning agent worth a look, and our roundup of AI tools developers actually use in 2026 puts all of them in context.

So which should you pick?

Match yourself to the situation:

You do heavy multi-file refactors and want the richest tooling — Claude Code. The MCP/subagent/hook ecosystem plus its refactoring track record make it the default for serious codebase work.

You already pay for ChatGPT or run on an OpenAI API key and want one bill — Codex CLI. No new subscription, no new billing relationship, good models.

You want an open-source agent you can audit, contribute to, or fork — Codex CLI. It's the only one of the two you can actually read.

You're a team that wants hooks, MCP, and subagent workflows — Claude Code. It's built for that, and the community has worn the paths.

You're trying terminal agents for the first time on a side project — start with whichever ecosystem you already live in. Got Claude Pro or Max? Use Claude Code. Got a ChatGPT plan? Use Codex CLI. Both are good enough to learn the workflow on, and switching later costs you almost nothing.

If you forced me to give one blanket answer for "most developers, most of the time, doing real work," I'd say Claude Code, because of the ecosystem and the refactoring strength. But "I already pay OpenAI and don't want another bill" is a perfectly good reason to land on Codex CLI, and you won't be missing the core agent loop — just some of the surrounding tooling.

Can you run both?

Sure, and plenty of people do. They're both just CLIs you run inside a repo; nothing stops you from keeping both installed and picking per task. A common pattern in 2026: Codex CLI for quick, scoped jobs when you're already in an OpenAI-flavored headspace or want the lighter tool, and Claude Code for the gnarly multi-file refactor or the long debugging session or anything that benefits from MCP servers and subagents. You can point both at the same repo on the same day. They don't conflict — they're two terminals. And if you want a model "second opinion" on a tricky change, running the same task through both and diffing the results is genuinely useful.

Quick FAQ

Is Codex CLI free? The tool is free and open source. You pay for model usage via an OpenAI API key or a ChatGPT plan that includes Codex. Current limits are on OpenAI's pricing page.

Is Codex CLI open source? Yes. OpenAI ships it as an open-source project you can read and fork. Claude Code is closed source.

Is Claude Code better than Codex CLI? For multi-file refactors and the richest tooling — MCP, subagents, hooks, slash commands — yes, in 2026. Codex CLI wins on open-source auditability and single-bill simplicity if you're already on OpenAI.

Can Codex CLI edit multiple files? Yes. It reads the repo, plans, edits multiple files, and runs commands, asking for approval based on your sandbox settings.

Which one costs less? Depends entirely on your usage and which plan you're on. Both can run usage-based off an API key or be bundled into a subscription. Run a real week of work through each and compare your actual bill — the marketing numbers won't match your workload.

Still weighing terminal agents against editor-based tools like Cursor and Copilot? Read the Claude Code vs Cursor vs GitHub Copilot comparison next — it puts all three on the same project with real numbers. More head-to-heads in the AI Tools category.

Cursor vs Aider: Which One for a Python Monorepo? (2026)

Hirak — Fri, 31 Jul 2026 14:30:02 +0000

Last updated: May 12, 2026.

You're in a big Python monorepo, and you're deciding between Cursor — the AI-first code editor — and Aider — the open-source terminal pair programmer that drives every change through git. Quick answer: Cursor if you want an all-in-one editor with great autocomplete and a GUI for reviewing multi-file diffs; Aider if you want to keep PyCharm or Vim, control exactly which files are in context, get every change as a reviewable git commit, and choose your own model to keep costs down. Both genuinely work in a monorepo. The decision is about how you want to work, not whether it's possible.

The short version

Want a polished all-in-one editor and you're fine switching IDEs? Cursor. Live in PyCharm or Vim and won't switch — or want bring-your-own-model with a git commit per change and direct cost control? Aider. Doing big agentic multi-file refactors and want a GUI to eyeball the diff before accepting? Cursor. Want an open-source tool you can script into CI or run headless? Aider. On a tight budget with your own cheap API key? Aider. Standardizing a team on one tool with easy onboarding? Cursor.

Everything below is "as of 2026," and both tools move quickly, so verify pricing and current features on their docs.

Cursor and Aider, one line each

Cursor is an AI-first code editor built on VS Code. You get Tab autocomplete that's genuinely good, a chat sidebar, codebase indexing so it "knows" your repo, and Composer/agent mode for multi-file edits. It's a subscription product with a free tier, and it uses frontier models under the hood — you mostly don't think about which one.

Aider is an open-source command-line AI pair programmer. You run it in your repo; it edits files and makes a git commit for each change it applies; it's model-agnostic, so you bring your own API key — Claude, GPT, whatever — and it works alongside the editor you already use. Its signature feature is the repo map: a compact, structural summary of your codebase that it feeds the model, so it has architectural awareness without loading every file. People who want a tight, auditable git workflow tend to love it.

Why the monorepo matters

In a small repo, "which AI tool" is mostly taste. In a monorepo with thousands of files across dozens of packages, real constraints show up. No model holds your whole repo, so both tools need a strategy for what to load, and you need to be deliberate about scoping to the package or files that matter. Cross-package changes — the kind that touch libs/auth and three services that import it — are where multi-file editing quality actually gets tested. Cursor indexes the codebase, which on a huge repo is a one-time cost plus ongoing maintenance; Aider's repo map is lighter, but you're more hands-on about which files you /add. And your tool has to play nicely with the monorepo plumbing — Bazel, Pants, uv workspaces, Poetry, pre-commit hooks, a CI that only runs affected targets — or at least not fight it.

So the question isn't "can it handle a monorepo." Both can. It's "which workflow do I want once the repo is too big to fit in the model's head."

Side by side

	Cursor	Aider
Interface	Full AI code editor (VS Code fork)	Command line, runs in a terminal
Open source?	No	Yes — open source, scriptable
Model choice	Frontier models under the hood; you mostly don't pick	Bring your own API key — Claude, GPT, etc.; you choose
Cost model	Subscription (free tier available)	Free tool plus your own model usage costs
Large-codebase handling	Codebase indexing; scope it on huge packages	Repo map for structure, plus the files you `/add`
Git integration	Standard editor git; you commit	A git commit per change, automatically — easy to review or revert
Multi-file edits	Composer/agent mode, GUI diff review	Edits multiple files; changes land as commits
Autocomplete	Strong Tab completion	Not its focus — it pairs on changes, not inline completion
Works with your existing editor?	No — Cursor is the editor	Yes — runs alongside PyCharm, Vim, VS Code
Learning curve	Low — it's VS Code plus AI	Moderate — CLI workflow, you manage context
Best for	All-in-one experience, autocomplete, GUI diff review, teams	Editor-agnostic devs, cost control, git-tracked changes, scripting/CI

Starting point, not gospel — both ship updates constantly, and the lines most likely to move are pricing, model availability, and the exact monorepo features.

Cursor in a Python monorepo

Cursor's pitch in a big repo is "the editor already knows your code." The codebase indexing means when you ask "where do we validate JWTs," it can find it without you pointing the way, and Composer/agent mode can make a coordinated change across several files and show you a diff to accept or reject in the GUI. If you want one window — editing, AI chat, autocomplete, diff review — and you're happy to switch IDEs, it's a smooth experience. The Tab autocomplete alone is a real bump in Python; it's good at finishing the obvious line.

The thing to keep an eye on is context limits on very large packages. Let it try to reason about a package with hundreds of files and you'll hit the ceiling and get worse results. The fix is the same as with any AI tool: scope it. Open the package you're working in, point Composer at the specific files or directory, and don't ask it to hold the whole monorepo in mind. And remember the index is something you maintain on a repo that changes a lot — exclude generated directories and build artifacts so it stays useful. If you're weighing Cursor against other editors more broadly, our best AI code editors comparison covers the field, and Cursor vs VS Code is the head-to-head for "should I leave plain VS Code at all."

Aider in a Python monorepo

Aider's pitch is control. You decide which files are in context — you /add path/to/file.py for the ones in play — and the repo map gives the model enough structural awareness of everything else to make sensible choices. In a monorepo that's a feature, not a chore. You're never wondering whether the tool quietly pulled in half the repo and torched the context budget, because you put the files there yourself.

Two things make it especially good for a disciplined monorepo workflow. One: a git commit per change. Every edit Aider applies becomes its own commit with a generated message, which means reviewing the AI's work is just git log, git diff, git revert — the same workflow you already use for code review, applied to the AI. On a big repo where you're careful about what lands, that's reassuring. Two: bring your own model. You pick it and pay for it directly. Want the cheap fast model for boilerplate and the expensive one for the gnarly refactor? You're in charge. On a tight budget with your own API key, Aider is the cost-control option, and it pairs naturally with the cheap-usage notes in our free AI coding tools roundup.

Because it's a CLI that runs next to your editor, PyCharm and Vim users don't have to give up their IDE — Aider just edits files and commits, and your editor sees the changes show up. It's also scriptable, so you can wire it into CI or run it headless for batch refactors. The tradeoff: it leans power-user. You manage context, you live in the terminal, and there's no inline autocomplete — Aider is for making changes, not finishing your lines. If you want to see where it sits relative to the assistants, Aider vs GitHub Copilot is the comparison.

So which should you pick?

Match the situation.

You want a polished all-in-one editor with great autocomplete, and switching IDEs is fine — Cursor. It's VS Code with AI baked in; the indexing helps it navigate the monorepo, and Composer handles multi-file changes with a GUI diff.

You live in PyCharm or Vim and won't switch — or you want bring-your-own-model, a git commit per change, and direct cost control — Aider. Keep your editor, control context, review changes as commits, pick your model.

You're doing big agentic multi-file refactors and want to see the whole diff in a GUI before accepting — Cursor. The diff-review UX is the draw there.

You want an open-source tool you can script into CI, run headless, or audit — Aider. It's the only one of the two you can do that with.

You're on a tight budget with your own cheap API key — Aider. No subscription; you pay only for the model tokens you use.

You're a team picking one tool with easy onboarding — Cursor. "It's VS Code, but smarter" is a five-minute pitch; Aider's CLI workflow takes more ramp-up.

If I had to give one default for "an experienced dev working solo in a large Python monorepo who cares about reviewing what the AI did," I'd say Aider, because the commit-per-change workflow and explicit context control fit a big repo's discipline so well. But "I want one window and great autocomplete and I'll happily use Cursor as my editor" is a perfectly good reason to pick Cursor — and a team will almost always onboard faster on it. For the bigger picture across all the AI coding tools, our Claude Code vs Cursor vs Copilot comparison and the roundup of AI tools developers actually use in 2026 are the next reads.

Tips for either tool in a big repo

Whichever you land on, a monorepo rewards discipline. Scope to one package or a handful of files — don't ask the tool to reason about the whole repo at once, you'll hit context limits and get worse output. Keep a CLAUDE.md or conventions file at the repo root, and per-package if needed, so the tool doesn't re-derive your patterns every session. Exclude generated and vendored directories from the index or repo map — build outputs, node_modules, generated protobufs are just noise. Use the tool's ignore file (Cursor's index ignore, Aider's .aiderignore) the way you'd use .gitignore. Review every diff — AI changes in a shared monorepo are exactly where you want a human in the loop; Aider's per-change commits make this trivial, and in Cursor you should actually read the Composer diff before accepting. And run the affected package's tests after each change — in a monorepo, "it compiles" isn't enough.

TL;DR

Both Cursor and Aider work in a Python monorepo; the choice is workflow, not capability. Cursor is the all-in-one AI editor — strong autocomplete, codebase indexing, GUI diff review, subscription pricing, easiest team onboarding; scope it on huge packages. Aider is the open-source CLI pair programmer — you control which files are in context (repo map for the rest), a git commit per change, bring-your-own-model for cost control, keeps your existing editor, scriptable. Pick Cursor for the polished single-window experience; pick Aider for control, auditability, and cost. Either way: scope to one package, keep a conventions file, exclude generated dirs, review every diff, run the package's tests. And verify pricing and features on the official docs, since both move fast.

Deciding between more than just these two? Claude Code vs Cursor vs GitHub Copilot: Honest 2026 Comparison puts three tools on the same project with real numbers. More head-to-heads in the AI Tools category.