Architecture · Surface

Where people build, and where the apps get used

The layer people actually touch. They build in the AI assistant they already use, and what they ship shows up somewhere their colleagues can find it and open it.

The three Helix layers: Surface, Control, and Foundation, with deploy and run flowing between them

Building is solved. Everything after it is not.

AI assistants made it easy for anyone to produce a working app. What they did not produce is a way for that app to be found, opened, and trusted by anyone else.

The app lives on a laptop

It works, it is useful, and nobody else can reach it. The value stops at the person who built it.

Sharing means sending a link

An HTML file in Slack or a deploy to a personal account. Whoever holds the link holds the app.

Everyone builds the same thing

Four teams build their own version of one lookup tool because none of them could find the others.

A new tool is a non-starter

Asking people to move into a different IDE or a visual builder means they will not move at all.

Build where you already work. Ship where people can find it.

Helix does not add another place to build. It adds the place the built thing goes.

Build with AI

The assistants your teams already use

Claude Code, Codex, Cursor, and any MCP-compatible assistant. These are the build surface, not something Helix competes with or replaces.

No new IDE
People keep the tool and the workflow they have. Helix begins at the point they want to go live.
No visual builder
The output is real code in familiar technologies, not a proprietary format locked to one vendor.
Tool-agnostic by design
Switching assistants later changes nothing about how apps reach production.

An app catalog

Find and run the approved apps

The other half of the Surface layer is where apps get used. Builders publish, and colleagues open the ones they are cleared for.

Discovery follows access
People see the apps they can open plus their workgroup's shared apps, so the catalog stays useful rather than noisy.
Published, not passed around
An app goes to the workgroup it was built for instead of to whoever happened to ask.
Reuse over rebuild
When the tool already exists and is findable, the next team uses it instead of building another.

From prompt to shared app

The whole arc, without a hand-off

Describe the app, build it, deploy it, send the URL. No separate hand-off to engineering in the middle.

One person, end to end
The person who understands the problem is the person who ships the tool, without waiting on a queue.
A real URL at the end
The result is software colleagues open behind SSO, not a file somebody has to download and trust.

Surface is the layer people touch. On one side it is where apps get built, in the AI coding assistants your teams already use, because the fastest route to adoption is to require no change at all. On the other it is where those apps get used: a catalog where builders publish and colleagues find what they are cleared to open. Between the two sits deploy, which is where the Control layer takes over.

Give your builders somewhere to ship

See how an app goes from a prompt to something a colleague can open.