Chat became the front door of software. You type "reconcile last week's vendor invoices and flag the weird ones", and twelve seconds later there's an answer: no dashboard, no filters, no menu. What's easy to miss: the answer didn't come from the chat. It came from a chain of automations running behind it (pull the invoices, read the PDFs, post to the accounting tool, notify the team, log every step, etc).
We've been building these chains for a while now, and internally we call them ghost automations: flows with no interface of their own, because the AI is the interface. Two things seem worth writing down:
- what shape a working ghost automation has
- why the middle part is where most companies get stuck
The shape of a ghost automation
Typical shape looks like:
- something triggers it: a request in chat, an incoming email, a schedule
- it executes across several systems (three to seven hops, usually)
- it returns a short, clean result to the AI, which talks to the human
- it leaves a receipt: who triggered it, what it touched, what came back
If one of the four is missing, the automation isn't really doing the job. Without the trigger it's a manual process with extra steps; without the receipt, nobody can answer "who ran this and why", and in any serious company that question comes, usually at the worst moment.
Why "ghost" and not just "headless"
A headless workflow has no interface by accident. A ghost automation has no interface by design, because the AI is the interface. The difference sounds cosmetic but isn't: a headless job runs because a developer scheduled it, a ghost runs because someone said something. That changes who can trigger work, when, and with what authorization, which is exactly where access management and logging stop being features and become the foundation.
Imagine a small plumbing firm (hypothetical, but a very typical request): the owner wants every customer whose service contract expires this quarter to get a reminder on Friday. He doesn't want a CRM, doesn't want a dashboard, and has no IT team. He wants to say "remind them" and have it happen. That's a ghost automation, and the dashboard version of it would have made him hate the whole topic.
Where most companies get stuck
Most teams we talk to already have step 1 (an AI front door) and step 3 (a summary back to the user). The middle is where things fall apart: flows glued together by hand, scripts on someone's laptop, results copied into spreadsheets (it works until the person who built it goes on vacation). No audit, no consistent execution, no answer to the receipt question.
What's missing is a layer underneath the AI that can:
- run a process the same way every time
- talk to real systems, not only the ones with friendly public APIs
- keep credentials safe and stay inside your network when the data is sensitive
- record everything in a form an auditor can actually read
This is roughly what platforms like flow8 are building: the layer the ghosts live on. The AI answers; the layer does.
What changes in practice
The scoping conversation changes. Instead of "what screen does the user need?", the question becomes "what sentence does the user want to say, and what has to run behind it?" The deliverable stops being a UI mockup and becomes a list of requests plus the executions behind them. We've started scoping projects this way, and it makes customer conversations simpler: people describe sentences much more easily than screens.
One open question we keep meeting: does the execution layer end up centralized (one per company) or does every department quietly grow its own? Audit and access control argue for one; org reality often says otherwise. Curious where readers land on this. Happy to compare notes!