From Selling Tokens to Hiring AI Employees: OpenAI DevDay 2026, the dots Agents, GPT-6.1 Sol Cost Crash, and a New AI Economy
From Selling Tokens to Hiring AI Employees: OpenAI DevDay 2026, the dots Agents, GPT-6.1 Sol Cost Crash, and a New AI Economy
1. Introduction: A Developer Conference That Got “Reset”
In the early morning of September 30, 2026 Beijing time, OpenAI held what it calls its “biggest-ever” DevDay in San Francisco. Near the end of the keynote, host Sam Altman invited “Tibo” (Thibault Sottiaux) — nicknamed the “reset god” by developers — to press the “reset key” and reset the account quotas of every ChatGPT user worldwide. The ritualistic closing aptly captures what this conference was about: OpenAI is resetting the pricing logic and product form of AI at scale.
In one go it released 21–25 updates across three core threads:
- Product reset: the always-on personal agent dots — not a “ask-and-answer” chatbot, but a “digital employee” driven by GPT-6 Astra, equipped with its own cloud computer, working 24/7;
- Cost reset: GPT-6.1 Sol — near-Astra performance at roughly 1/5 the standard token price, turning “high performance” from luxury into a daily consumable;
- Business resonance: a redesigned subscription that shifts from “charging per token” to “charging per AI-employee workload and runtime speed”; meanwhile reports say OpenAI plans to raise $30B at a ~$1.4T valuation, with annualized recurring revenue (ARR) nearing $70B.
In one sentence: OpenAI is repositioning AI from “tool” to “employee,” and pivoting from “selling compute” to “selling productivity.” This is a paradigm reset around “how AI makes money, how it’s priced, and how we relate to it.” This article deconstructs it from both the technical-architecture and business-model dimensions.
2. dots: Upgrading “Chatbots” into “Always-On Digital Employees”
dots is the heaviest product of the conference and OpenAI’s direct answer to Meta’s Muse (which lifted Meta’s stock ~25% in a month).
Its essence: AI moves from “passive response” to “proactive duty.”
┌─────────────────────────────────────────────────────────────────┐
│ dots: a long-running, self-driving AI employee │
├─────────────────────────────────────────────────────────────────┤
│ · Model: GPT-6 Astra (OpenAI's strongest, most-aligned model) │
│ · Form: 24/7 running, owns an independent cloud computer │
│ (cloud computer + browser + code writing/testing) │
│ · Connectivity: operates the computer, extracts info from │
│ connected apps, research/drafting/software development │
│ · Entry: message/call in ChatGPT, Slack, Teams, future SMS │
│ · Autonomy scope: give it a goal + define ops it may do │
│ · Initial quota: 1 dot per user; future "dot teams" │
└─────────────────────────────────────────────────────────────────┘
dots’ design core is “give responsibility to the AI while keeping control with the human.” Altman stresses: users customize instructions and set custom rules about what dots “cannot do,” then hand over “as much responsibility as they feel comfortable with.” This “goal authorization + permission boundary + human oversight” framework is exactly the key engineering challenge for long-running agents — the “scope authorization” we discussed earlier is now a product-level design principle here.
At the engineering level, behind dots is a simplified “AI-employee runtime” model, which this pseudocode illustrates — how it “carries a long-running task”:
# ============================================================
# Concept: dots-style long-running agent task loop
# Design: break a big goal into stepwise execution that
# can be taken over by a human at any time
# ============================================================
from dataclasses import dataclass
from enum import Enum
from typing import List
class JobStatus(Enum):
QUEUED = "queued"; RUNNING = "running"
AWAITING_USER = "awaiting_user"; DONE = "done"
@dataclass
class DotTask:
goal: str
allowed_ops: List[str] # whitelist of ops it may do
forbidden_ops: List[str] # custom rules: must not do
tools: List[str]
status: JobStatus = JobStatus.QUEUED
class Dot:
"""always-on digital employee: self-drives on goal, hands back on breach"""
def __init__(self, task: DotTask):
self.task = task
self.history: List[dict] = []
def checkpoint(self):
"""permission checkpoint before each action"""
for step in self._plan(self.task.goal):
if step.op in self.task.forbidden_ops:
self.task.status = JobStatus.AWAITING_USER
return self._hand_back_to_user(step) # red line → pause
if step.op in self.task.allowed_ops:
self._execute(step) # whitelist → act
self.history.append({"op": step.op, "state": "ok"})
self.task.status = JobStatus.DONE
return self._report_done(verbose=False) # truthful report, no hiding
# Key design: long-running ≠ full proxy
# advance on whitelist, pause before red lines, full audit trail
This loop has three-layer value: self-driving (no need to wait for the user on every instruction), boundary-respecting (runs in the permission whitelist, hands control back on overreach), and accountable (full logging, truthful reporting that doesn’t hide progress — directly addressing earlier worries about “deception tendency/withholding”).
And for developers, OpenAI turns the capability behind dots into callable, composable building blocks.
3. GPT-6.1 Sol: Putting “Near-Astra Performance” at 1/5 the Price
If dots answers “what AI can do,” GPT-6.1 Sol answers “is doing it expensive” — and its answer is “absurdly cheap.”
As a major upgrade to GPT-6 Sol, GPT-6.1 Sol excels in agentic coding, computer use, and professional work, with performance comparable to GPT-6 Astra — Altman even says it’s “smarter than Astra” in some ways — yet its standard API token price is about 1/5 of Astra’s. OpenAI also teases “GPT-6.1 Sol Ultra-fast” arriving in the coming days.
This “near-flagship performance at category-bottom price” is essentially cost-cutting driving adoption: when high-performance inference becomes cheap, agents can be used in routine, high-frequency, large-scale workflows “without counting cost.”
Let’s quantify and compute how much more Sol can run on the same budget:
# ============================================================
# Concept: how Sol's 1/5 price changes Agent capacity by an order
# of magnitude — same budget, how much more can it do
# ============================================================
class ModelCost:
def __init__(self, in_per_M, out_per_M):
self.in_per_M = in_per_M # cost per M input tokens
self.out_per_M = out_per_M # cost per M output tokens
astra = ModelCost(in_per_M=15.0, out_per_M=60.0) # illustrative baseline
sol = ModelCost(in_per_M=15.0/5, out_per_M=60.0/5)
def per_million_message_cost(m, in_tokens=600, out_tokens=1500):
return (m.in_per_M * in_tokens + m.out_per_M * out_tokens) / 1e6
def throughput_per_budget(model, budget=100.0):
return budget / per_million_message_cost(model)
print("Astra per-msg cost:", per_million_message_cost(astra))
print("Sol per-msg cost:", per_million_message_cost(sol))
print("Budget-wise Sol runs",
round(throughput_per_budget(sol)/throughput_per_budget(astra)), "x more")
Key conclusion: when API price drops to 1/5, the number of agent calls the same budget can carry rises ~5x. This isn’t linear tweaking; it’s a gating change in “can I put agents into daily pipelines.” Before, only high-value tasks could afford a strong model online 24/7. Now Sol makes “high-frequency, massive, scaled automation” possible — exactly the premise for dots/agent adoption.
4. “Ultra-fast + Pay-per-workload”: A Pricing-Paradigm Reset
Even more noteworthy than the price cut is OpenAI’s reshaping of “how AI is charged.” It clearly points to: from selling tokens to hiring AI employees, priced by delivered workload and runtime speed.
Two complementary lines surfaced:
- Ultrafast: token generation speed in Codex up to 8x higher (up to 300 tokens/s), up to 6x in the API. Same task, done faster — speed, for the first time, becomes a premium dimension that can be separately billed.
- New tiers: a new $500/month Pro 500 (25x Plus quota, exclusive Astra Ultrafast), while cutting usage quotas on Pro 200 (developers gripe most about “halved quota”).
A diagram shows this “AI-employee pricing” logic:
┌─────────────────────────────────────────────────────────────────┐
│ From "selling tokens" to "hiring AI employees": three shifts │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Past (model/tool) Now (AI employee/output) │
│ ────────────────────────────── ────────────────────────── │
│ billing unit token usage delivered work + speed │
│ audience developers developers+enterprise+users │
│ value prop stronger=costlier do more, faster, pricier │
│ top tier more tokens faster speed (Ultrafast) │
│ sub logic quota=tokens quota=AI employee hours │
│ │
│ supporting pieces │
│ · 1 dot per user; chat not counted to quota │
│ · Pro 500 = "hire a super employee with ultrafast mode" │
│ · ultrafast consumes quota faster (fast = pricier) │
└─────────────────────────────────────────────────────────────────┘
The industry implication is profound: once “AI employee” becomes the billing unit, the market’s yardstick shifts from “model grade/param count” to “how much real work a unit of cost produces.” That raises a new requirement for model vendors — not just “who’s smarter,” but “who, within the same budget, gets more done, faster, and more reliably.”
5. Platformization: Making ChatGPT the “Entry Point for Human-Agent Collaboration”
Beyond product and models, this DevDay sent a strong platformization signal: OpenAI wants to turn ChatGPT from “a chat app” into “the super-entry for human-agent collaboration,” akin to a “WeChat mini-program + account system.”
┌─────────────────────────────────────────────────────────────────┐
│ OpenAI platformization: from "product" to "ecosystem base" │
├─────────────────────────────────────────────────────────────────┤
│ ① Collaboration ChatGPT Space: users+teammates+multiple │
│ agents on one dynamic page, @dot to assign │
│ ② Capability 8 dev capabilities: Codex Harness OSS, │
│ Codex cloud, Codex Secure Cloud, Agents API │
│ beta, OpenAI private intelligence, │
│ Sign in with ChatGPT, Plugin Extensions, │
│ OpenAI Marketplace │
│ ③ Connectivity Amazon Bedrock managed agents, Microsoft │
│ Agent 365 integration, Base Ten open models │
│ ④ Distribution OpenAI software market (buy third-party SW │
│ with committed spend; first 32: Adobe/Figma/ │
│ Sierra/Harvey/PAN etc.) │
│ ⑤ Base 1.2B weekly active users (>10B this summer) │
└─────────────────────────────────────────────────────────────────┘
Two details stand out:
- Codex Harness open-sourced: opening the execution framework behind agentic coding, combined with Agents API — OpenAI wants to be simultaneously the “provider of agent capability” and the “foundation of the agent ecosystem,” matching its slogan “let developers ship native experiences directly to our 1.2B users.”
- Software market + spend portability: enterprises can use their OpenAI committed spend to buy third-party software (Adobe/Figma/legal/cyber). This basically replicates the cloud-vendor “commitment” model in AI — sticky enterprise customers via existing procurement budgets.
6. The Business Panorama: A $1.4T Valuation Raise, ARR Nearing $70B
Finally, zoom out to OpenAI’s commercial stance. Data released alongside DevDay is striking:
- Funding: per Bloomberg, after delaying IPO, OpenAI plans to raise at least $30B in a bridge round at a pre-money valuation of ~$1.4T. If it succeeds, its valuation could again surpass Anthropic’s recent ~$965B private valuation.
- Revenue: per Axios, OpenAI’s ARR is nearing $70B, up over 70% since the start of Q3, with B2B revenue up over 100%.
- IPO: Altman says “no IPO timetable yet,” insisting it must first make a “defensible safety commitment,” placing alignment before capability iteration. By contrast, Anthropic filed for IPO in June (est. November; valuation perhaps near $2T), and Musk’s SpaceX completed its largest-ever IPO in June.
A diagram puts the three players side by side:
┌─────────────────────────────────────────────────────────────────┐
│ 2026 AI commercialization: three players' plays and positions │
├─────────────────────────────────────────────────────────────────┤
│ │
│ OpenAI val ~$1.4T (raising) ARR ~$70B 1.2B weekly users │
│ play: dots+Sol+ChatGPT entry → selling AI employees │
│ IPO: no timetable yet, safety first │
│ │
│ Anthropic val ~$965B / near $2T filed IPO (est. Nov) │
│ play: Sonnet 5.5/Opus launches + AWS Bedrock sweep │
│ IPO prospectus warns of "existential risk" │
│ │
│ SpaceX/xAI already public (largest IPO) Grok Bot │
│ play: registering dot.com and redirecting to Grok │
│ │
└─────────────────────────────────────────────────────────────────┘
This explains why OpenAI, on one hand, charges hard at commerce ($30B raise, $70B ARR), and on the other, handles safety cautiously (canceling Astra, deferring IPO, putting alignment ahead of capability). Because in the gap between high valuation and high risk, OpenAI must answer both “prove you’re worth $1.4T” and “prove you won’t run away” at the same time.
7. Conclusion: The Underlying Logic of the Next AI Economy
Looking back at this DevDay, we can distill four industry logics taking shape:
- Product: from “Q&A” to “duty” — dots marks AI’s mainstream form shifting from “chat assistant you ask” to “long-running, self-driving digital employee” with cloud computers, app connectivity, and continuous work.
- Cost: from “sky-high” to “cost-driven adoption” — GPT-6.1 Sol delivers near-Astra performance at ~1/5 the price, turning high-performance agents into a daily capability you can use without counting cost — the premise of agent scale.
- Pricing: from “selling tokens” to “hiring AI employees” — Ultrafast makes “speed” a separately billed premium; new tiers price by “workload and runtime speed” — AI formally enters the “productivity pricing” era.
- Platform: from “product” to “ecosystem” — Codex Harness open source, Agents API, software market, 1.2B weekly users; OpenAI wants to own not just the model but the “entry space for human-agent collaboration.”
And when Altman pressed the “reset key,” what got reset wasn’t just a quota — it’s a collective reset of “what AI actually is, and how it should be priced and trusted.” When AI starts drawing a salary as an “employee,” what humans truly must get used to is no longer just “how to use it,” but “how to set its rules, divide responsibility, and draw boundaries.” That is the hardest homework this conference leaves the industry.