Runway Solaris: The First 'Interface World Model' That Generates Apps as You Use Them

On August 31, 2026, Runway launched something that doesn’t fit neatly into any existing AI category. Solaris is what Runway calls an “Interface World Model” — the first of a new family of AI systems that generate software interfaces in real-time, as you use them.

The question Runway poses is simple and profound: “What happens when an operating system generates apps and websites as you use them?”

The answer could reshape how we interact with software, how AI agents navigate digital environments, and what it means to “build an app” at all.

The Concept: Generated Software vs. Pre-Built Software

Today, software is built through a relatively uniform process. Designers craft the visual layout. Developers translate that layout into code — HTML, CSS, JavaScript. The result is a product with predetermined buttons, menus, screens, and interactions. Developers anticipate potential interactions in advance and program them.

This method is efficient and reliable. But it has a fundamental limitation: users can only interact in ways the developers anticipated. Every button, menu, and screen was designed by someone who guessed what you might want to do.

Solaris takes a fundamentally different approach. Instead of converting a visual design into code, Solaris directly generates the visual interface. The model produces the screen incrementally while simultaneously reacting to user actions. The interface doesn’t merely display a program — the generated environment itself serves as the interface.

Think of it as the difference between a store with fixed aisles and shelves (current software) and a store that rearranges itself around what you’re looking for (Solaris).

How Solaris Works

Solaris builds on Runway’s Gen-4.5 video model and its earlier GWM-1 world model. The technical approach is novel:

Frame-by-Frame Generation

Solaris generates the interface frame by frame, similar to how a video model generates video frames. But instead of playing a pre-recorded sequence, each frame is generated in response to the user’s current action.

User Actions as Inputs

The system interprets user actions — clicks, drags, voice commands — as inputs that influence subsequent frames. When you drag an object, the next frame reflects the new position. When you speak, the next frame reflects the requested change.

Integrated Language Model

An integrated language model helps ascertain user intentions and dictates how the scene should evolve. This is what allows Solaris to understand natural language commands and translate them into interface changes.

Real-Time Interaction Speed

The biggest technical challenge was speed. Runway modified the video model to produce frames sequentially and minimized processing steps required for frame generation. The result is real-time interaction — the interface responds as you act, not after a delay.

What Solaris Enables

Runway provides several illustrative examples that show the range of what Interface World Models can do:

Virtual Showrooms

An online clothing retailer where users enter a virtual showroom instead of navigating product listings. They select a shirt and drag it onto a virtual representation of themselves to visualize how it would look. The showroom generates around their interaction — no pre-built product pages, no fixed navigation.

Voice-Controlled Design

A room design application where users instruct the AI to relocate furniture or alter colors verbally. No menus, no toolbars, no preset options. The room responds to natural language commands in real-time.

Drag-and-Drop Cooking

A cooking application where users drag ingredients directly into a bowl to create a salad, observing the environment’s responsive changes. The interface is a kitchen that responds to your actions, not a recipe page with steps.

Interactive Learning

If a user requests an interactive demonstration of combustion, Solaris visually generates the scenario, enabling hands-on experimentation. The interface is the experiment — not a video of it, not a simulation with preset controls, but a generated environment you can interact with.

Continuous Visual Responses

While conventional AI chatbots respond with text, images, or hyperlinks, Solaris is engineered to provide continuous visual responses. The interface is always evolving, always responding. This makes software interactions feel more like engaging in a simulated environment than navigating web pages.

Why Solaris Matters for AI Agents

The most immediate practical implication of Solaris may be for AI agents — and specifically, for the biggest bottleneck in production agent deployment: brittle UI navigation.

Current AI agents that navigate websites and apps depend on static UI elements. They look for buttons by location, text, or CSS selectors. If a button moves, changes color, or gets renamed, the agent breaks. This brittleness is one of the main reasons agent deployments fail in production — the web is dynamic, but agent navigation is static.

Interface World Models could solve this. With Solaris, the interface adapts to the agent’s needs in real-time. The agent doesn’t need to memorize button locations because the interface generates itself around the agent’s intent. This eliminates the fundamental brittleness of static UI navigation.

For organizations deploying AI agents for web-based tasks — form filling, data extraction, workflow automation — this could significantly improve reliability. The AI Agent Automation Consulting service is already tracking Interface World Models as a potential solution to the UI navigation problem that limits production agent reliability.

The Paradigm Shift: Post-App Software

Solaris represents something larger than a new AI capability. It represents a paradigm shift in what software is.

The App Era (Current)

• Software is pre-built by developers
• Users interact through predetermined interfaces
• Changes require development cycles
• AI agents must learn static interfaces
• Every app is a separate walled garden

The Generated Software Era (Solaris)

• Software is generated in real-time
• Users interact through adaptive interfaces
• Changes happen instantly through natural language
• AI agents interact with interfaces that adapt to them
• Interfaces emerge from intent, not from code

This shift has implications for every layer of the software stack:

For UX design: The role shifts from designing fixed interfaces to designing the rules and constraints that govern how interfaces generate. The canvas isn’t a screen — it’s a set of interaction patterns.

For development: The role shifts from writing code that defines interfaces to training models that generate interfaces. The skill set moves from frontend engineering to model curation and interaction design.

For AI agents: The role shifts from navigating static interfaces to collaborating with adaptive ones. Agents become more reliable because the interface meets them where they are.

For businesses: The opportunity shifts from building apps to building the models and data that generate experiences. The competitive advantage moves from UI design to interaction intelligence.

What This Means for Business Leaders

1. Generated Interfaces Could Transform Customer Experience

If your business involves customer-facing software — e-commerce, design tools, learning platforms — generated interfaces could transform how customers experience your product. Instead of navigating fixed menus and screens, customers could interact with interfaces that adapt to their needs in real-time.

The CTO Technology Advisory service helps organizations assess how emerging interface technologies could transform their customer experience — and build the technical roadmap to adopt them.

2. AI Agent Reliability Could Improve Significantly

If Interface World Models solve the brittle UI navigation problem, AI agent deployments become significantly more reliable. If you’re struggling with agents that break when websites change, this technology could be the solution — once it matures.

3. The Definition of “Building Software” Is Changing

If interfaces generate themselves, what does it mean to “build software”? The skill set shifts from frontend development to interaction design, model curation, and intent understanding. Organizations that invest in these skills now will be prepared for the generated software era.

4. Early Access Is Available — But Selective

Solaris is still in early access. Runway is working with key partners to launch publicly, and interested organizations can request early access via their form. If your business could benefit from generated interfaces — particularly in e-commerce, design, or education — it’s worth exploring.

5. The Post-App Era Is Coming

Solaris is a first step. The post-app era — where software generates itself around user intent — is not here yet. But the direction is clear. Organizations that understand this shift and prepare for it will have a significant advantage when the technology matures.

The AI Strategy for Business consultation now includes emerging interface technology assessment: evaluating how Interface World Models and generative UI could affect your digital strategy and building a roadmap for adoption.

The Bottom Line

Runway’s Solaris is the first Interface World Model — a system that generates software interfaces in real-time based on user engagement. It’s built on video model technology, it produces continuous visual responses, and it enables interactions that feel like engaging with a living environment rather than navigating a static app.

The implications are significant. For UX design: a shift from designing fixed interfaces to designing interaction rules. For AI agents: a potential solution to the brittle UI navigation problem. For software itself: the beginning of the post-app era, where interfaces emerge from intent rather than code.

Solaris is early. It’s in selective early access with key partners. The technology will need to mature before it’s ready for broad enterprise deployment. But the paradigm shift is real — and the organizations that understand it, prepare for it, and invest in the skills it requires will be the ones that benefit when it arrives.

The question Runway poses — “What happens when an operating system generates apps and websites as you use them?” — is not a hypothetical. It’s a preview. And the answer is: everything changes.