Sam Altman Wants to See What You Built with GPT-5.6 Sol

Introduction

Sam Altman has invited developers and creators to share the most interesting things they have built with GPT-5.6 Sol.

The offer is deliberately simple: post a project, show what the model helped create, and the builder behind the coolest result will receive a special gift from the OpenAI archives.

This is not a formal competition with published judging criteria, submission categories, or a fixed deadline. It is an open showcase started through a post on X. Even so, the response quickly turned into a useful snapshot of how early users are applying GPT-5.6 Sol outside ordinary chat.

The submissions span scientific visualization, education, business automation, developer infrastructure, web design, interactive storytelling, and game experiments. Together, they show the role OpenAI wants Sol to play: not merely answering coding questions, but helping people finish ambitious, multi-step products.

An Open Build Showcase, Not a Conventional Contest

Altman’s post says that he wants to see interesting things people have built with GPT-5.6 Sol and will send the creator of the coolest project a special gift from the OpenAI archives.

No detailed rules were attached to the announcement. There is no public scoring rubric explaining how originality, technical complexity, usefulness, design, or commercial potential will be weighted.

That informality is part of the appeal. Builders can show almost anything, provided it demonstrates a meaningful use of the model.

The submissions highlighted in the source article fall into several broad categories:

Category	Example
Scientific visualization	A weather-model satellite simulator
Education	A tool that converts video links into structured courses
Business automation	A virtual office staffed by AI employees
Developer infrastructure	An agent-friendly GitHub alternative
Web and design	Personal websites and studio sites
Interactive visualization	A 3D history of OpenAI
Games	AI-assisted recreations and interactive experiments

The projects differ widely in polish and completeness. Some are functioning products, while others appear closer to prototypes or public demonstrations. They should be treated as examples of what builders reported creating, not as independently audited production systems.

Project 1: A Weather-Model Satellite Simulator

One of the most technically distinctive projects came from a builder using the name Drew.

The project turns output from professional weather models such as WRF and HRRR into physically rendered satellite imagery. Users can then move a virtual camera through the same reconstructed three-dimensional storm.

The example shown in the post uses a WRF reconstruction of the 1974 Super Outbreak, one of the most significant tornado outbreaks in recorded U.S. history.

This is more than a standard dashboard.

A conventional weather interface usually presents maps, contours, radar images, or pre-rendered animations. A navigable 3D simulator needs to combine several layers:

1. Read and interpret numerical weather-model output.
2. Convert scientific variables into visual properties.
3. Reconstruct cloud and storm structures.
4. Render the result efficiently.
5. Provide a camera system for interactive exploration.
6. Preserve enough physical meaning for the visualization to remain useful.

A model can assist with data pipelines, rendering code, shaders, interface logic, debugging, and documentation. Domain expertise is still essential because a visually impressive cloud field is not automatically a scientifically valid representation.

The strongest use of AI in this type of project is not replacing atmospheric science. It is reducing the engineering work needed to turn specialist data into an explorable tool.

Project 2: Turning Video Links into Structured Courses

Another builder used GPT-5.6 Sol to create a course-production tool.

The workflow described in the source is straightforward:

1. Paste a Telegram video link.
2. Process the video and its content.
3. Organize the material into a structured learning experience.
4. Present it through a cleaner course interface.

This category is especially relevant because content transformation requires several capabilities to work together:

• Media retrieval.
• Transcription.
• Topic segmentation.
• Title and summary generation.
• Lesson ordering.
• Interface generation.
• Progress tracking.
• Search or question answering.
• Source preservation.

The difficult part is not producing a summary. A useful course needs structure, clear boundaries between lessons, accurate references, and a way for learners to understand where each claim came from.

For production use, the builder would also need to consider copyright, access permissions, private-channel content, transcription accuracy, and whether the original creator allowed redistribution.

Project 3: A Virtual Company with 12 AI Employees

A builder named Tomoya presented an “AI Employee Office” powered by GPT-5.6 Luna and Sol.

The interface resembles a pixel-art management game. Inside the virtual office, 12 AI workers are organized into five departments and appear to operate continuously.

The listed responsibilities include:

• Sales proposals.
• Customer-support work.
• Accounting entries.
• Meeting notes.
• Strategy and planning.
• Executive analysis reports.

The visual presentation is playful, but the underlying product pattern is serious.

Many businesses do not want one general chatbot. They want several bounded agents, each with a narrow responsibility, different tools, and a clear place in the workflow.

A multi-agent office needs more than character names and animated desks. A reliable implementation must answer questions such as:

• Which data can each agent access?
• Can one agent assign work to another?
• How are conflicting outputs resolved?
• Which tasks require human approval?
• What happens when an agent fails?
• How are actions logged?
• How are costs divided across departments?
• Can the business trace a final result back to its source?

The project is a useful visualization of agent orchestration. Its real value depends on whether the agents produce verifiable work rather than only generating plausible-looking activity.

Project 4: Clotho, an Agent-Friendly Code Platform

A builder using the name Preetham developed Clotho with GPT-5.6 Sol and Rust.

The source describes Clotho as an alternative code-hosting platform designed to support both people and AI agents. It combines repository management with model-hosting ideas associated with platforms such as Hugging Face.

The dashboard includes areas for:

• Repositories.
• Compute.
• Organizations.
• Agent activity.
• Secrets.
• Notifications.
• Repository-level infrastructure.

The project reportedly supports multiple interaction routes for agents, allowing automated systems to read, write, and operate on code. It also connects repositories with GPU compute and includes repository-level Tailscale networking.

This reflects an important shift in developer tooling.

Traditional code platforms were designed around a human opening a repository, reading an issue, creating a branch, and submitting a pull request. Agent-native platforms must also support machine identities, scoped credentials, isolated execution environments, structured task queues, and detailed action logs.

An agent-friendly repository platform should ideally provide:

1. Short-lived credentials.
2. Least-privilege access.
3. Isolated workspaces.
4. Reproducible execution.
5. Protected branches.
6. Human review gates.
7. Complete audit trails.
8. Limits on network and secret access.

The project demonstrates why AI coding agents may eventually influence the architecture of code-hosting systems, not only the code stored inside them.

Project 5: Websites and Frontend Design

Many participants used GPT-5.6 Sol for personal websites, studio sites, and interactive frontend experiments.

This aligns with OpenAI’s official positioning. The company says GPT-5.6 improves visual hierarchy, layout judgment, document design, and frontend work.

Its prompting guidance still recommends giving the model a clear design system and requiring it to inspect the rendered result before finishing.

For website projects, a useful workflow is:

1. Define the audience and conversion goal.
2. Provide the existing brand system.
3. Specify required pages and states.
4. Ask the model to inspect the current components.
5. Preserve responsive behavior.
6. Render the result.
7. Test mobile and desktop layouts.
8. Review accessibility, performance, analytics, and SEO.
9. Verify forms, links, and deployment settings.

A visually polished page can still fail as a website if it lacks search metadata, clear navigation, fast loading, reliable forms, or a useful call to action.

The interesting part of the GPT-5.6 examples is not simply that the model can produce attractive CSS. It is that it can combine design, implementation, inspection, and refinement in one longer workflow.

Project 6: An Interactive 3D History of OpenAI

One of the more theatrical submissions used GPT-5.6 Sol to create an interactive 3D visualization of OpenAI’s history.

The project reportedly uses 6,832 points to form portraits of Sam Altman and Thibault Sottiaux, OpenAI’s core product leader. Users can navigate the visualization and move through events from OpenAI’s history.

The work combines:

• Point-cloud rendering.
• Portrait reconstruction.
• Timeline data.
• Interaction design.
• Animation.
• Historical content.
• Responsive web performance.

Projects like this are well suited to model assistance because they contain many small but connected engineering tasks. The model can help create the data structure, rendering logic, navigation, layout, and content pipeline.

The main risk is factual accuracy. An interactive historical product should distinguish official events, public reporting, commentary, and jokes rather than merging them into one visual narrative.

What These Projects Reveal About GPT-5.6 Sol

The examples do not prove that Sol can independently build every application from a single prompt.

They do show several patterns in how builders are using the model.

1. The Model Is Being Used as an Engineering Partner

The projects involve more than isolated code completion.

Builders are using Sol for:

• Repository exploration.
• Architecture.
• Data transformation.
• Interface implementation.
• Debugging.
• Tool integration.
• Documentation.
• Visual refinement.
• Longer task coordination.

2. Builders Are Combining Models

The AI office project uses both Luna and Sol.

This matches OpenAI’s intended model selection:

Model	Best fit
GPT-5.6 Sol	Complex reasoning, coding, research, and polished outputs
GPT-5.6 Terra	Everyday workloads balancing quality and cost
GPT-5.6 Luna	High-volume or cost-sensitive repeatable work

A production system does not need to route every task to the most capable model. A stronger architecture uses Sol only where the added capability justifies the price.

3. Interactive Outputs Matter

Several projects are simulations, platforms, dashboards, or websites rather than static text.

This shows a change in user expectations. The desired output is increasingly something people can operate, inspect, and continue developing.

4. Agent Infrastructure Is Becoming a Product Category

Clotho and the AI office both treat agents as persistent actors rather than temporary chat sessions.

That creates demand for:

• Agent identity.
• Permissions.
• Execution environments.
• Task queues.
• Memory.
• Monitoring.
• Cost controls.
• Review interfaces.

Why OpenAI Is Promoting Builder Examples

The public showcase is useful marketing, but it also supports OpenAI’s product strategy.

GPT-5.6 Sol is positioned as a model for complex professional work and agentic coding. OpenAI wants developers to evaluate it by completed outcomes rather than conversational style.

User-generated examples help the company:

• Demonstrate use cases that were not selected by its marketing team.
• Show the model working across different industries.
• Encourage people to test the product.
• Gather feedback about failure modes.
• Identify strong builders and potential customers.
• Create social proof around a new model.
• Shift discussion from benchmarks to finished artifacts.

The special gift is less important than the public invitation. The post turns model adoption into a visible community event.

GPT-5.6 Sol’s Efficiency Positioning

OpenAI’s official launch materials emphasize performance per dollar.

On the Artificial Analysis Coding Agent Index, OpenAI reports that GPT-5.6 Sol with max reasoning scored 80, used less than half the output tokens and less than half the time of Claude Fable 5, and cost approximately one-third less.

On Agents’ Last Exam, Sol reportedly reached a score of 53.6. OpenAI says medium reasoning outperformed Fable 5 while costing roughly one-quarter as much on its estimates.

These are vendor-reported benchmark comparisons. Their practical meaning depends on workload, prompt design, tool use, caching, reasoning level, and the number of subagents.

A cheaper successful run is not the same thing as a lower per-token price.

GPT-5.6 Sol’s API pricing is listed as:

Token type	Price per 1 million tokens
Input	$5.00
Cached input	$0.50
Output	$30.00

Requests with very large input contexts are subject to higher long-context rates.

A complex agent may also create additional cost through web search, computer use, code execution, repeated repository reads, and parallel subagents.

The Other Side of the Launch: Usage Complaints

Some early Codex users reported that GPT-5.6 consumed their plan usage faster than expected.

These reports do not necessarily contradict OpenAI’s benchmark efficiency claims.

A model can use fewer tokens for a benchmark while a product session still consumes more quota because it:

• Works for longer.
• Reads more repository context.
• Performs more tool calls.
• Spawns subagents.
• Rechecks its work.
• Produces more polished outputs.
• Uses a higher reasoning setting.
• Runs several workstreams in parallel.

Thibault Sottiaux responded publicly with three updates:

1. OpenAI temporarily removed the five-hour usage-limit restriction for Plus, Business, and Pro plans.
2. The company said it was rolling out changes intended to improve Sol’s efficiency and reduce usage consumption.
3. It announced a usage reset after Codex and ChatGPT Work reached six million active users.

These were temporary operational changes, not permanent guarantees about every plan.

Users should consult the current OpenAI help center and in-product usage information because limits can change based on plan, rollout stage, system capacity, and abuse-prevention controls.

Model Competition Benefits Builders—Within Limits

The source article places the showcase inside a wider period of competition among frontier AI companies.

OpenAI was promoting GPT-5.6 Sol, while other companies were also releasing or promoting new coding, agent, image, and video models.

Competition can benefit users through:

• Lower effective cost.
• Temporary access extensions.
• Faster model improvements.
• Better developer tools.
• More generous previews.
• Quicker responses to usage problems.
• Greater choice between capability and cost tiers.

The benefit is not automatic.

Frequent model changes can also make production planning more difficult. Teams need stable pricing, transparent usage data, predictable rate limits, and clear deprecation policies.

For professional use, the right question is not “Which company is winning this week?”

It is:

Which model and workflow produce the required result at a cost, latency, and reliability level the business can sustain?

How to Build a Strong GPT-5.6 Sol Submission

The public post does not provide formal judging rules. Based on the examples, a strong submission is likely to demonstrate more than a generated landing page.

1. Start with a Real Problem

Choose a task where the finished product is clearly useful:

• Visualizing specialist scientific data.
• Reducing repetitive operations.
• Creating a new developer workflow.
• Turning unstructured material into a usable product.
• Making a complex dataset interactive.

2. Show the Working Result

A short video or live link is more convincing than a description.

Show:

• The input.
• The model-assisted workflow.
• The finished output.
• A difficult interaction.
• A failure that was fixed.
• What a user can now do.

3. Explain Sol’s Role

Be clear about what the model contributed.

For example:

• Designed the architecture.
• Implemented the renderer.
• Debugged a data pipeline.
• Created the interface.
• Refactored the repository.
• Coordinated subagents.
• Generated tests.
• Reviewed the final output.

Avoid implying the model did everything autonomously when substantial human work was required.

4. Include Technical Specifics

Useful details include:

• Programming languages.
• Frameworks.
• Models used.
• Tool integrations.
• Dataset sources.
• Deployment environment.
• Approximate build time.
• Main failure mode.
• How the result was verified.

5. Protect Private and Licensed Material

Do not publish:

• Customer data.
• Private repositories.
• Credentials.
• Unlicensed media.
• Personal information.
• Internal company prompts.
• Proprietary datasets without permission.

6. Make the Project Inspectable

A public repository, technical note, or clear product walkthrough makes the submission easier to evaluate.

It also turns the project into something other builders can learn from rather than a one-time social post.

常见问题

What is Sam Altman’s GPT-5.6 Sol build challenge?

It is an informal public invitation posted on X. Altman asked people to share interesting things built with GPT-5.6 Sol and said the creator of the coolest project would receive a special gift from the OpenAI archives.

Is there an official submission form or deadline?

The original announcement does not provide a formal application form, deadline, or judging rubric. Builders are responding publicly to the X post.

What can GPT-5.6 Sol be used for?

OpenAI positions Sol for complex coding, research, professional work, computer use, and long-running agent workflows. The showcased projects include simulations, websites, business agents, education tools, and developer platforms.

Is GPT-5.6 Sol cheaper than competing models?

OpenAI reports stronger performance per dollar on several benchmarks, but real cost depends on task length, token use, tools, reasoning level, caching, and subagents. Sol’s API price is $5 per million input tokens and $30 per million output tokens.

Why did some Codex users report high usage?

Long agent sessions may read large repositories, use tools repeatedly, review their work, and run subagents. These activities can consume plan allowances quickly even when the model is efficient on standardized benchmarks.

Did OpenAI permanently remove Codex’s five-hour limit?

The public update described the removal as temporary. Current plan limits should be checked in OpenAI’s official help documentation and the product interface.

Do I need to use only GPT-5.6 Sol?

No. OpenAI recommends Terra for a balance of quality and cost and Luna for faster, high-volume work. Some applications can route complex steps to Sol and simpler tasks to lower-cost models.

Can I submit a website created with GPT-5.6 Sol?

Yes. Website projects were among the examples shared by users. A strong submission should demonstrate a meaningful use case, working functionality, responsive design, and a clear explanation of the model’s contribution.

相关工具

• GPT-5.6 Sol: OpenAI’s flagship GPT-5.6 model for complex coding and professional work.
• Codex: OpenAI’s agentic coding environment for repository work, implementation, testing, and review.
• ChatGPT Work: A workspace for turning goals and connected context into completed professional outputs.
• OpenAI Responses API: The primary API for building tool-using and multi-turn model workflows.
• OpenAI Multi-Agent: A beta feature for coordinating parallel GPT-5.6 subagents.
• Rust: The systems programming language used to build the Clotho project highlighted in the source.
• Tailscale: A private networking platform mentioned in connection with Clotho’s repository-level compute network.

Related Links

• Sam Altman’s Build Invitation: The original public request for GPT-5.6 Sol projects.
• GPT-5.6 Official Announcement: Official capabilities, benchmarks, model positioning, and examples.
• GPT-5.6 Sol Model Documentation: Context window, pricing, tools, reasoning settings, and model ID.
• GPT-5.6 Prompting Guidance: Official guidance for coding, frontend, visual, and professional workflows.
• OpenAI API Pricing: Current model and tool pricing.
• Thibault Sottiaux’s Usage Update: The announcement about temporary limit changes, efficiency improvements, and usage resets.
• ChatGPT Work: OpenAI’s product page for professional, agentic work.
• GPT-5.6 System Card: Safety evaluations and deployment information for the GPT-5.6 family.

Summary

Sam Altman’s open invitation has turned into an informal showcase of what early GPT-5.6 Sol users are building. The strongest examples go beyond chat and code snippets, combining the model with scientific data, business workflows, interactive interfaces, developer infrastructure, and multi-agent systems.

The projects also reveal the practical trade-off behind advanced agentic models. Sol can coordinate complex work and produce polished results, but longer sessions, large contexts, tool use, and subagents can consume significant tokens and plan capacity.

For builders, the most useful lesson is to judge the model by a finished, inspectable outcome. A strong project solves a clear problem, explains the model’s contribution, shows the real workflow, and gives users something they can operate.

The coolest GPT-5.6 Sol project will not necessarily be the one with the longest prompt—it will be the one that turns model capability into a clear, working product.