OpenAI launches GPT-6.1 Sol and Dots, its answer to Meta Muse

Key takeaways

• GPT-6.1 Sol delivers near-flagship performance at one-fifth the API cost of GPT-6 Astra.
• Dots are always-on AI agents that work across 4,000+ apps in the background and learn your preferences over time.
• Sol changes the economics for production deployments where Astra may be overkill.
• Dots shift the product model from chatbots to persistent agents, but you trade fine-grained control for convenience.
• Test Sol against your own benchmarks and start Dots experiments with low-risk internal workflows before customer-facing use.

What shipped

On September 29, 2026, OpenAI held its annual DevDay conference and announced more than 20 product updates (https://openai.com/index/devday-2026-recap). Two releases stand out for builders and business operators: GPT-6.1 Sol, a new language model, and Dots, a system of persistent AI agents.

GPT-6.1 Sol (https://openai.com/index/introducing-gpt-6-1-sol) delivers what OpenAI calls "near-Astra intelligence" at one-fifth the API cost of its flagship GPT-6 Astra model. Both input and output token prices drop dramatically. According to TechCrunch (https://techcrunch.com/2026/09/29/openai-launches-gpt-6-1-sol-says-it-nearly-matches-gpt-6-astra-and-costs-less/), the model shows significant improvements over the original GPT-6 Sol across complex professional tasks including code writing and debugging, document understanding, and multi-step business workflows.

Dots (https://openai.com/index/introducing-dots) are always-on AI assistants powered by GPT-6 Astra. The Verge reports (https://www.theverge.com/ai-artificial-intelligence/1002033/openai-dots-launch-muse-competitor) that Dots run on their own cloud computer and can access a web browser plus more than 4,000 supported apps. You interact with a Dot through a text-message-like interface or by voice call from ChatGPT on web, desktop, or mobile. Each Dot is represented by a customizable avatar, a direct nod to Meta's Muse product.

How it works

GPT-6.1 Sol sits between the original GPT-6 Sol and GPT-6 Astra in the model lineup. The pricing advantage is clear: you pay 20 percent of Astra's rate for performance that OpenAI claims is nearly equivalent. The company highlights three use cases where Sol shines: coding and computer use, document understanding, and professional workflows that require multiple steps. For developers who have been paying Astra rates for tasks that do not need absolute top-tier reasoning, Sol offers a cheaper path without a meaningful quality drop.

Dots work differently than a chatbot you open when you need an answer. TechCrunch notes (https://techcrunch.com/2026/09/29/openai-launches-dots-its-bubbly-agentic-avatar/) that Dots are designed to operate independently of any specific hardware or interface, pursuing user-defined goals continuously in the background with minimal oversight. They learn your preferences over time. The agents can work across connected apps while you do something else. OpenAI positions them as proactive assistants that keep complex projects and everyday tasks moving forward while you stay in control.

The technical backbone matters. Dots run Astra, not Sol, which means they have access to OpenAI's most capable reasoning model. They execute tasks by browsing the web and interacting with thousands of integrated apps through APIs. Our read is that this is OpenAI's version of function calling taken to its logical conclusion: instead of a model returning a JSON payload that your code interprets, the agent handles the full execution loop.

What it changes for builders

The Sol release changes the economics of deploying capable models in production. If your application currently uses Astra for tasks like document extraction, code generation, or structured data transforms, you can likely switch to Sol and cut your inference bill by 80 percent. That cost reduction matters for any product where LLM calls sit in the critical path and scale with user activity.

Dots shift the product paradigm. Instead of building a chatbot interface and managing state, context windows, and function calls yourself, you can delegate continuous task execution to an agent that already has app integrations and a persistence layer. If you have been prototyping an AI feature that needs to check email, update a CRM, and post a Slack summary, Dots may let you skip months of integration work.

The trade-off is control. When you write the orchestration code, you decide retry logic, error handling, and guardrails. When you hand a goal to a Dot, you trust OpenAI's agent runtime to make those decisions. For some use cases that is freeing. For others, especially in regulated industries or where brand voice and business rules are strict, it may be a non-starter.

Gotchas and limits

OpenAI claims Sol delivers "near-Astra" performance, but "near" is doing work in that sentence. The sources do not publish benchmark scores or define how close is close enough. Test Sol against your own evals before you migrate production traffic. Edge cases and subtle reasoning failures can surface only under real-world load.

Dots depend on integrations. The Verge mentions support for more than 4,000 apps (https://www.theverge.com/ai-artificial-intelligence/1002033/openai-dots-launch-muse-competitor), but the sources do not list which apps or describe how those connections are authenticated and authorized. If your stack includes niche SaaS tools or legacy systems, Dots may not reach them. Even for supported apps, you will need to grant OAuth permissions and trust OpenAI to act on your behalf across those platforms.

Dots run continuously and learn preferences over time. That persistence is the point, but it also means the agent accumulates context and makes inferences about what you want. The sources do not detail how you audit, correct, or reset that learned behavior. If a Dot starts making assumptions you disagree with, the path to retraining or constraining it is unclear.

How we would use it

We would start with Sol for any customer project currently using Astra where the task is well-defined and the output is verifiable. Code generation, document parsing, and data transformation are good candidates. Run Sol and Astra in parallel on a sample of production prompts, compare outputs, and measure where they diverge. If the error rate is acceptable, switch and bank the cost savings.

For Dots, we would experiment with internal workflows first. Set up a Dot to monitor a project channel, summarize daily progress, and update a status doc. Give it a narrow, low-risk goal and watch how it handles ambiguity and errors. If it works, expand the scope. We would not put a Dot in a customer-facing loop until we understand its failure modes and have a human review gate.

We would also look hard at what Dots expose about OpenAI's agent runtime. If the orchestration logic, tool-use patterns, and error-recovery strategies prove robust, that is valuable signal for how we build our own agentic systems. If Dots struggle with the same problems we see in our agent prototypes, that tells us the technical challenges are still unsolved and we should set customer expectations accordingly.