An operating system exists so you don't have to think about the hardware. You double-click a program. You don't allocate its memory, arbitrate its access to the disk, or check whether it's allowed to open the network. The kernel does all of that underneath, the same way, every time. The whole point is that running a program is safe and boring by default.
Block just shipped an operating system for internal tools, and the writeup reads exactly like one.
It's called Block App Kit. An employee describes a tool in plain language, an agent builds it, and it ships to coworkers in hours. Since launching in March, the catalog passed a thousand distinct apps, weekly active users climbed from the low hundreds into the thousands, and about 80% of the people building are in Sales, Support, Legal, and Finance -- not engineering. Jack Dorsey called it the fastest-adopting tool in the company's history. The apps are the programs. The platform is the kernel.
The point is who's building
Look again at that 80%. The people shipping these apps are in Sales, Support, and Finance, and that's the whole reason to build something like this. For years, "I need an internal dashboard" meant filing a ticket and waiting in the engineering queue, behind everything with a customer attached. The tool was three weeks out, if it came at all.
Block App Kit deletes the queue. Anyone describes the tool they need and has it that afternoon, and the leverage lands on everyone who used to depend on engineering for a five-line internal app. That's why a company bothers to build this: not to generate apps, but to let every person operate without an engineer in the loop.
What the kernel actually does
The impressive part of Block App Kit isn't the part that writes the app. It's the part that lets a freshly generated app touch real systems without anyone getting hurt. Who's allowed to open it. Which services it can reach. Where the API keys live, and how an app uses one without ever holding it. What happened, recorded, on every call out. Authentication, authorization, secret management, data-access controls -- on by default. Block's own security org started pointing people to it as the sanctioned way to ship.
That's a kernel. It manages the dangerous shared resources -- credentials, data, the network -- so the thousand apps stacked on top don't each have to reinvent how to handle them safely. Strip that layer out and you don't have an operating system. You have a thousand programs free-handing access to production.
Why every company ends up here
The demand for this is not a Block-sized phenomenon. Gartner counts 16.2 million citizen developers in 2026, most of them outside IT, and projects 75% of new applications will be built with low-code by year's end. Every company already has people who could describe a useful tool in a sentence. What they don't have is the kernel underneath.
So the apps get built anyway, and they ship without one. A scan of 1,400 vibe-coded applications turned up 2,038 critical vulnerabilities, more than 400 leaked secrets, and 175 instances of exposed PII, including medical and financial records. Across enterprises, AI-assisted developers ship code three to four times faster but introduce security findings at ten times the rate, and expose secrets at roughly double. That's what an OS-less world looks like. Fast, and leaking.
Build the kernel or adopt one
Block could write its own. It has hundreds of engineers and can afford to pull a team off customer-facing work to build infrastructure that never ships to a customer. Ramp built its internal tooling in-house for the same reason -- the headcount was there, and the math worked. That's the rounding error of companies who can fund a kernel from scratch. For everyone else, a multi-quarter team dedicated to a tool no customer ever sees is exactly the project that doesn't get approved.
So they face the choice the industry has faced at every platform layer before this one. Nobody writes their own operating system anymore. Nobody writes their own database, or their own cloud. They adopt one and build on top, and the layer that used to be a moonshot becomes the floor everybody stands on.
What the kernel looks like when you don't build it
General Input is that layer, available without the engineering project. The build step is the one you expect: someone describes the tool they need in plain language, and an agent assembles a working app from it. Everything wrapped around that build is the actual product.
Every app runs in an isolated sandbox, never on someone's laptop and never with a standing pipe into production. Share an app with a teammate and it runs as you, using your connected accounts, so the person using it gets the result without ever touching a key or a token. The builder gets distribution, the teammate gets the tool, and the credential stays sealed off from both.
Underneath sits the same credential model Block had to engineer. The agent that writes the app never sees an API key. Credentials are encrypted at rest, injected at runtime inside the sandbox, and stripped before anything reaches the model. Below the credential, a proxy enforces what each connection is allowed to do, down to the individual operation across thousands of tools, so a call an app shouldn't make is blocked before it ever leaves the sandbox. Every call that does go out is written to an audit trail. Security isn't a setting someone remembers to switch on. It's the floor the apps run on.
That is the whole difference between a demo and a platform. A vibe-coded app impresses one person on one laptop. The same app on General Input can be handed to the entire company, touch the systems it needs to touch, and leave a record of everything it did, without a single credential ever passing through the model that built it.
The operating system of the agentic company
Block proved the demand and the design in a single post. An employee describes a tool, an agent builds it, and it ships safely because the platform makes "safely" the default -- the way a good OS makes running a program something you stop thinking about.
These are the agentic operating systems of the future. Every company will run one. The app builder on top was the easy part. The kernel underneath was the engineering, and the only question left is whether you build it or it's already built for you.