DynamisOS

Software was built for everyone.
That's why it feels made for no one.

DynamisOS shapes a unique interface around how every person works — generated live, from the same data.

Get Started

The thesis

Dynamic Software Interfaces

By Ankit Gupta

Before AI, users of a piece of software all interacted with the same interface. There were only light customizations like a few different views or theme and color options. When users think about "personalization" like on Netflix, it still has the same layout for everyone, just different imagery. As a result, most software has a one-sized-fits-all feel rather than being hypercustomized to a user. As an example: the way I use an email is very different from how most college students use email, yet all email clients look basically the same.

The exception is in enterprise software, where forward deployed engineers customize software for each customer to make it a great experience for them.

We think that coding agents have now gotten good enough to allow users to become their own forward deployed engineers and more radically customize the software they consume. I'm imagining users designing widely different interfaces for their use cases — perhaps my email client looks more like a task list, and a students' looks more like an events calendar. But these two interfaces likely share some underlying primitives and design decisions that a software team can build and ship.

We think that in the future, software companies will ship these shared primitives with full intention that users will heavily modify the final interfaces.

To enable this future, we will have to rethink the whole stack of software delivery. How will a developer make software that can be accessed by the user's coding agents? Do they have to deliver source code rather than packaged binaries? Can they only modify front-end visual elements, or are there ways for them to modify middleware on the fly to enable more interesting use-cases? If you're a radical thinker looking to define the future of software, we'd love to hear from you.

The stack

Ship primitives. Get interfaces.

One team builds the building blocks. Every user (or their coding agent) composes the interface they actually need — without filing a ticket.

Primitives

Typed, composable building blocks with real product semantics — the same ones your engineers ship, exposed to agents as first-class APIs.

Studio

A canvas where each user designs the surface they want to use — by describing it, dragging primitives, or asking their agent to compose it for them.

Agent

A coding agent that already knows your primitives, so customization is a conversation: 'show my inbox as a task list' — done, on top of your real backend.

How it works

From one source of truth to a thousand personalized surfaces.

The full stack: from your primitives on the server, through the agent, to the interface your user actually sees — and can edit.

  1. 01

    Ship your primitives

    Your team defines the shared building blocks of your product — data sources, actions, validations, workflows. Designed with full intention that users (and their agents) will rearrange them into radically different interfaces.

  2. 02

    Expose them to agents

    Primitives become addressable over a typed protocol — readable by any coding agent, composable in any framework. Source code or runtime API, not just packaged binaries.

  3. 03

    Let the user compose

    Each user (or their agent) reads your primitives and composes the interface that fits how they work — sometimes automatically, sometimes through a conversation in Studio.

  4. 04

    Stay bound to real data

    The composed interface is rebuilt from the same primitives every time, so it always works against real data, respects real permissions, and never becomes a shadow fork of your app.

YC RFS · Dynamic Software Interfaces

Let's rebuild
software delivery.

If you're thinking about coding agents, primitives, and what comes after packaged binaries — we'd love to hear from you.

[email protected] · San Francisco

FAQ

What is DynamisOS, in one sentence?

The software stack for the era of agent-customized interfaces — your team ships primitives, every user (or their coding agent) composes the final UI on top of them.

Why now?
How is this different from personalization today?
Who is this for?
Do our users need to know how to code?
How does this relate to enterprise forward-deployed engineers?
What do you ship today, and what are you building?
What changes for our software delivery?
We're a YC RFS — how do we get involved?