OpenAI DevDay 2026: What Actually Matters for Builders (Dots, Sign In, Agents)

Models got faster; the platform got wider

GPT-6.x family updates, “ultrafast” inference, and private intelligence for enterprises are real product lines — and they matter for unit economics. But most indie builders I talk to are not blocked on “slightly smarter weights.” They are blocked on distribution, auth, and who runs the loop when an agent fails at 2 a.m.

That is why Dots and the refreshed plugin story landed harder for me than another benchmark slide.

If you have been following the agent wave this year, none of this arrives in a vacuum. We wrote about why every founder’s stack shifted in 2026 when agents stopped being demos and started touching production data. DevDay is OpenAI’s attempt to own the checkout line for that shift — models plus routing plus billing identity in one place.

Dots: agents with an audience attached

Dots is OpenAI’s push into persistent, background agents — always-on helpers with their own execution context, closer to what Meta and Google are doing with their agent surfaces than to a single chat thread.

The part I keep coming back to is not the autonomy pitch. It is routing: a user states an intent inside ChatGPT, the platform matches a workflow, and a third-party plugin or mini-app does the work — sometimes before the user ever visits your marketing site.

OpenAI also talked about plugins that feel less like 2023 demos: panels pinned in the sidebar, interactive canvases, recommendations mid-conversation when intent lines up. Execution over awareness — your tool gets hired for a job, not merely mentioned.

If you have shipped niche automation before, this is the same lesson as our agent harnessing post: the model is not the product; the loop plus tools plus permissions is. Dots just puts that loop inside ChatGPT’s front door.

The 2023 plugin era taught a harsh lesson: discovery without execution is a dead end. OpenAI’s new pitch — sidebar panels, pinned mini-apps, intent-matched recommendations — only works if your plugin returns structured feedback fast enough that the agent can close the user’s task. That is the same contract we use when wiring agents into everyday websites: small surface area, clear tool schema, human-readable errors when something fails.

For a minimal “hire me inside ChatGPT” prototype, you do not need a platform team on day one. A thin API plus a tool definition that maps to one boring workflow (normalize CSV columns, draft a permit checklist, summarize a franchise PDF) is enough to learn whether routing picks you. Our 150-line web search agent is the same shape — tiny loop, one tool, prove the contract before you polish UI.

Sign in with ChatGPT: SaaS economics, flipped

Sign in with ChatGPT is the other headline that changes spreadsheets. Third-party apps can authenticate against a user’s ChatGPT account and, in the narrative OpenAI told on stage, lean on that user’s existing token allowance (Pro, Team, Enterprise — details will matter in the fine print).

Rough mental model:

• Your app handles OAuth against ChatGPT.
• Lightweight AI features can run without you prepaying inference for every free signup.
• You monetize workflow depth — compliance, seats, SLAs, proprietary data — not resold tokens.

That opens micro-SaaS shapes that used to die on the first API bill: one-job utilities (CAD cleanup, franchise PDF checks, Shopify catalog normalization) where the value is done-for-you, not “chat with PDF.” It rhymes with the micro-SaaS ideas that are actually making money — narrow job, obvious ROI, distribution that does not require a six-month SEO ramp.

Pair Sign-in-with-ChatGPT with a thin web client. If your app is mostly server-side agents plus markdown or static pages, keep the browser bundle small — we have been arguing bundle size should come before image tweaks on performance work, and free-tier AI apps will feel that twice over when every route loads a chat shell.

For founders treating agents as the product, not a feature bolted onto a CRUD app, the AI operating system for SaaS founders framing still applies: one loop for research, one for execution, one for publishing — DevDay just offers ChatGPT as a possible identity and inference layer for the execution step.

It also raises governance questions we already track in agent auditing and compliance: whose logs, whose data processing agreement, and what happens when a plugin oversteps? If your plugin writes to a customer CRM, read CRM and admin patterns for local businesses alongside compliance — the data model outlives the demo.

Decisions API and Agents API (computer use)

Two infrastructure pieces worth separating:

Decisions API — fast, finite classification (text or vision in, labeled route out). Good for “which playbook runs next?” without chaining three verbose LLM calls. Think routing, not reasoning.

Agents API with computer use — managed multi-step agents that can call tools, compact context, and interact with UIs. OpenAI wants to own the boring orchestration so you bring domain logic.

Compare that to rolling your own stack in Python agent SDKs: frameworks give you Lego; DevDay is selling assembled highways. You still need a sandbox story when those agents touch production systems — and a map of who is building sandbox SDKs and APIs so you are not guessing in a vacuum.

Decisions API is where I would replace brittle “if message contains X” logic in existing automations. Agents API + computer use is where I would not start unless the workflow truly requires clicking legacy UIs — otherwise prefer APIs and structured tools, like the scrape-and-act loop in from finding clients to a smart SaaS dashboard.

If you prefer to self-host the HTTP layer, nothing stops you from wrapping OpenAI’s APIs behind a small Hono.js service: one file for auth, one for tool execution, deploy anywhere. DevDay does not replace that; it adds optional distribution and sign-in on top.

The four-step loop worth designing around

Whether the surface is Dots, your own app, or a CLI harness, the durable pattern looks the same:

1. Trigger — webhook, document uploaded, inventory threshold, calendar event.
2. Decision — platform or your classifier picks a path.
3. Action — your code, plugin, or human-in-the-loop API does the work.
4. Feedback — structured status back to the agent so it can retry or close the task.

Strategic shorthand: OpenAI will happily own Decision inside ChatGPT. Defensible startups still tend to own two of Trigger, Action, and Feedback — the places your domain data and liabilities live.

That loop is also how we think about content agents internally: research and drafting stay server-side; the public site stays thin. See what a content pipeline looks like at scale — triggers (trends, Reddit, CRM rows), decisions (which brief to write), actions (publish markdown), feedback (rankings, human review). Dots is the consumer-facing version of the same architecture with a different front door.

Field sales teams care about the same split. Onboarding old industries with AI workflows is mostly Trigger + Action (OCR, lead capture, Instagram carousels) with humans in the loop — exactly the kind of vertical plugin that could surface inside ChatGPT when someone says “fix my invoice pile” instead of “show me AI tools.”

Where I would look for greenfield ideas

Not a exhaustive list — just shapes that fit the DevDay story:

• Physical or regulatory last mile — APIs that connect agent intent to verified humans (permits, inspections, freight exceptions). Digital-only plugins are crowded; liability-heavy workflows are not.
• Plugin analytics (“GEO for agents”) — simulate prompts, measure how often your tool gets picked, fix metadata so routing stops dropping you on intent mismatches.
• Harness-first vertical tools — narrow industry, one trigger, one action, excellent feedback JSON; distribute via Dots instead of SEO alone.
• Outbound agents for B2B — Reddit, LinkedIn, and maps prospecting agents already look like plugins waiting for a marketplace; the moat is verified data and rate limits, not the LLM call.

Discovery inside ChatGPT is a new kind of SEO

When plugins compete on intent matching, metadata becomes the product. Tool names, descriptions, example utterances, and failure messages are how you get routed — closer to answer-engine optimization than classic blue-link SEO. Run prompt simulations the way you would keyword research: “file my permit,” “clean this CAD export,” “normalize Shopify variants” — and measure whether your definition wins.

Voice and phone workflows are a parallel channel. AI voice agents for SMB receptionists solve a different interface, but the feedback schema problem is identical: the platform needs a structured outcome, not a transcript of small talk.

What I am ignoring (for now)

• Speculating on exact model names or pricing tiers until docs and SDKs match the keynote.
• Rebuilding my entire stack on computer-use day one — UI agents are still audit and sandbox problems first, demos second.
• Treating “1.2B users” as guaranteed top-of-funnel for every plugin. Marketplaces always concentrate on clear intent match and reliable completion.

Bottom line

DevDay 2026 reads like OpenAI betting that agents plus identity plus marketplace routing matter more than selling raw tokens alone. For builders, that means designing for hireability inside ChatGPT, frictionless sign-in, and loops you can prove in logs — the same harness discipline we have been writing about, now with a platform front door.

If you ship a plugin or Sign-in-with-ChatGPT experiment, tell us what broke first: routing, auth scopes, or feedback schema. That is usually where the real engineering starts.

Read next on iHateReading

• Agent harnessing — model vs harness vs framework
• Python agent SDKs compared — when to self-assemble vs buy OpenAI’s stack
• AI agent sandbox landscape — blast radius before computer use
• AI agent auditing in 2026 — logs and procurement
• New AI agent SDKs and how programming changed — background on the tooling wave

Source video: https://www.youtube.com/watch?v=Fls_onRviPM