Everyone builds now. Almost nothing ships.

Somewhere in your company right now, someone who has never opened a pull request is shipping working software.

A finance analyst is describing a reconciliation tool to an AI assistant and getting back code that runs. A RevOps lead is turning a spreadsheet into an app over lunch. An ops manager is finally building the tool that’s been stuck in IT’s backlog for months. None of it is going through engineering, and though plenty of these apps would be genuinely valuable, almost none of it will reach production.

This is the world we now live in, and it’s the world we built Tray Helix for. Here’s the whole story, and it starts with one we’ve seen before.

Three acts, every time

Act one: a new capability shows up and adoption outruns everyone’s plan for it.

Act two: the sprawl. Too much of the new thing, everywhere, with no owner and no controls.

Act three: a governance layer forms, and only once it exists does the wave actually pay off.

When cloud came along, it got CASBs and cloud security posture management. SaaS got SSO and identity providers. APIs got API management. Now it’s AI’s turn.

These apps are deep into act two. Act three looks like a control layer again, this time in the form of a runtime, one that governs what ships without taking the AI assistant away from the people building with it.

Here’s why act two got so big, so fast.

Everyone builds now

The adoption debate is over. In Stack Overflow’s 2026 developer survey, 84% of developers use or plan to use AI coding tools. GitHub Copilot is deployed at roughly 90% of the Fortune 100. Claude Code is past a $2.5B revenue run-rate a little over a year after launch. OpenAI Codex crossed 5 million weekly active users, and about 1 in 5 of them is not a developer.

Building software has left the engineering org. Anyone can describe what they want in plain language and get a prototype back. But it doesn’t last long.

Problem one: almost nothing ships

Roughly half of resourced enterprise AI POCs reach production. Of those that ship, only about 5 to 10% deliver measurable P&L value. Compound the two stages and fewer than 1 in 20 AI builds ever get deployed and deliver value.

Here’s why: a working prototype is not a running app. Running apps require hosting, a database, credentials, an identity layer, logging, cost metering, and an owner of record. For AI-built apps, no one owns that work. The analyst who vibe-coded an app during lunch is not going to suddenly start thinking like a platform engineer, so the app stays on a laptop and the tokens spent building it turn into pure cost.

And those costs can really bite, because the market stopped paying for effort and started demanding real ROI. “We rolled our AI app out to 25,000 people” used to sound impressive. Now it just sounds like there’s nothing else to report.

Tokens are a cost. Shipped software is the value. Most enterprises are buying plenty of the first and getting almost none of the second.

The CISO’s instinct is to gate harder, but that’s the wrong move

A small share of these apps, maybe 20%, will carry most of the value. But you can’t find that 20% while it’s still sitting on laptops, and gating harder doesn’t solve that; it just makes sure fewer apps ever reach the production stage where the winners could prove themselves.

Since you can’t pick the winners upfront, you have to make production cheap and governed for all of it, so the winners surface on evidence: real usage, a real owner, a tracked cost. Fund what moves a real metric, retire the rest cleanly, and govern the whole portfolio the entire time.

Gartner projects 60% of vibe-coded apps will be retired by 2028 for failing to deliver predictable value, which is exactly the point: most of them should go, so long as the process for finding out which ones is cheap and fast.

That’s problem one: get more of it to production. Problem two is what happens to the apps that already made it there.

Problem two: what ships is ungoverned

The apps that do escape the laptop aren’t in much better shape. They ship with no identity, no managed secrets, no audit trail, and no place in anyone’s inventory.

• 82% of organizations found unknown AI agents running in their environments, and 68% had believed their visibility was strong.
• Thousands of vibe-coded apps already have live credentials sitting on the open web.
• 98% of FinOps teams now manage AI spend, up from 31% two years ago, and finance still can’t attribute a single dollar of it to an app or a team.

Regulators aren’t waiting either. The EU AI Act carries penalties up to €35M or 7% of global turnover for prohibited practices, and up to €15M or 3% for high-risk violations.

Every ungoverned app is a future incident with a timestamp you don’t get to pick.

Introducing Tray Helix

Today we ship Tray Helix, the governed runtime for AI-built apps.

Helix makes shipping an AI-built app as easy as describing it, and it makes that same app enterprise-governed the moment it goes live. Those two things have never come together. Helix is the first path that gives you both, for everything your people build.

One command takes an app from Claude Code, Codex, or Cursor to a live URL. Identity, managed secrets, cost caps, and a full audit trail attach as it ships. Not bolted on after. IT stands up no infrastructure. The builder never sees a credential. Every app is seen, owned, and accounted for from its first request.

That combination, the ease of a prompt with the control of an enterprise platform, is the whole point. Helix is not a scanner that hunts for shadow apps after the fact. It is not a policy PDF. It is where your apps run, and it is what turns a drawer full of shadow apps into a portfolio you can see, own, and measure.

Here’s how it works.

Tray Helix architecture

The Surface is where people build and find apps: build with an AI assistant, browse an app catalog, go from a prompt to a shared URL.

The Control layer is what IT governs: access control, approvals where risk warrants them, audit, and observability.

The Foundation is the orchestration kernel: a credential broker that keeps secrets out of code, a project service that owns the deploy lifecycle and versioning, and the managed runtime itself.

Apps deploy from Surface into Control, and run from Control on the Foundation. That is the shape of Helix.

The deploy lifecycle. A builder installs the Helix CLI (@trayio/helix-cli), runs helix login, and helix init scaffolds a project. They build inside that project with their AI assistant. When they ask it to ship, the assistant runs helix deploy under the hood. The build is compiled and packaged server-side, deployed to Tray’s managed runtime, and assigned a URL. What was a folder on a laptop is now a running, addressable app.

The credential model, which is the whole security story. Apps reach real systems (Salesforce, Google Sheets, Slack, and the supported list) through Tray auth aliases. The builder and the AI assistant reference an alias. They never see a raw secret. “No hardcoded secrets” is therefore true by construction, not by policy. There is nothing to hardcode, nothing to paste into a prompt, and nothing to leak. Rotate a credential once, centrally, and every app using it picks up the change with no per-app redeploys.

Instrumentation is not optional. Every app is instrumented at deploy, so IT watches activity, logs, and metrics from the first request. Governance here means more than a checklist. It means you can answer a real question about any running app in minutes instead of email archaeology.

Five capabilities, over everything that ships

• AI Visibility. One live pane with every app in production: owner, connections, activity. Nothing hidden.
• AI Deployment. One command from Claude Code, Codex, or Cursor to a live app on the managed runtime, governance applied as it ships.
• App Security. Enterprise SSO and identity on every app, managed auth so nothing ships with hardcoded secrets, and scoped, auditable role-based access. A vibe-coded app has no identity story of its own. That gap is the first thing Helix closes.
• Cost Management. LLM, token, and compute spend attributed per app and team, with budgets and caps that act before the overrun.
• App Registry. An internal marketplace where builders publish and people find the apps they are cleared to use, with an approval step where it matters.

Helix is part of a unified platform

One platform, two products: Tray iPaaS integrates your data, and Tray Helix deploys and governs the apps your people build with AI. Both run on the same foundation, the one already handling 1T+ processes a year across 700+ connectors, so adopting Helix means no new governance system to stand up.

Where this goes

Same three acts as always. For AI-built apps, act three is a governed runtime.

Stand one up and the pile of ungoverned apps on laptops becomes a portfolio of governed, running, cost-attributed software: seen, owned, secured, and measurable. That is the entire difference between AI spend and AI value.

Your teams build with AI. Helix runs and governs it all.

Alistair Russell is co-founder and CTO of Tray.ai.