You've let the agents in. Now you're choosing between speed and control.
Every team using agents on client work ends up at the same fork, and both ways down are bad.
Let them run
Work gets fast, and nobody can tell you what shipped, what it cost, or whose API key ended up in a prompt. You find out from the client.
Keep your hands on everything
You keep control and lose the reason you brought agents in. You become the bottleneck you were trying to remove.
The fork exists because the tools hand you an agent and nothing around it. No shared record, no receipt, and no way to close the loop from the work back to what it earned.
One brief in. A campaign out. Every step named, costed and yours to approve.
Take a job an agency actually runs. This is the whole loop Hub is built to close, from the brief to what it earned.
- 01
It already knows the client
Brand voice, messaging pillars, products, pricing and the design system live in a knowledge folder. Plain files, versioned, readable by any agent. Every step reads from it.
- 02
The work runs as named steps
Keyword research, competitor analysis, copy, a landing page built from the client's own design system, tag and analytics setup, then the ads. Each step is a job with an owner and an output.
- 03
It checks itself before it asks you
The agent tests the page it just built. If the skill says so, a second model reviews the first one's work. You see the result, not the rough draft.
- 04
You approve the three that matter
The landing page, the ad copy, the spend. Three decisions, each on one exact version, each with the agent's own projection attached as evidence.
- 05
The record closes the loop
Form to lead to converted to what it earned, per variant and per product, pulled back from analytics and the ad platforms. The campaign and the revenue sit on the same record.
- 06
It keeps watching
A scheduled check watches spend, clicks and dead buttons. When something slips it raises a task with a proposed fix, and one tap puts the fix through the same gate.
That loop is the product. Most tools give you a piece of it and leave you to carry the result between them by hand.
Four things you don't get by pointing an agent at your business.
One shared record
The record is the interface, not a chat thread and not one tool's private database. Your clients, work, knowledge and results are one thing with many views, so eight tools stop disagreeing about what's true.
You can see what it did
Every attempt is written down, the allowed ones and the refused ones, and a refusal names its reason. Nothing happens that you can't go back and read.
The cost is visible
Tokens and dollars land on the job as it runs, per model. A cost that isn't known is left blank. It is never shown as zero.
You stay in charge
Anything that spends money, publishes, or writes to somewhere outside your business needs a named person's yes on one exact version. Change the version and the approval dies with it.
Four moments belong to a person. Everything between them is a machine's job.
You decide what to do, whether the plan is right, whether the result is right, and whether it goes live. That's the whole of your involvement, by design.
- 01
Something starts work
You ask, a schedule fires, or a signal arrives. Every door makes the same thing: a task on the record, owned by a person, against a client.
- 02
A plan gets proposed
A cheap model reads the client's history and proposes the scope, the steps and a budget. You approve it once. Low-stakes work skips this, so nobody taps twice for trivia.
- 03
It runs, capped
A plain background program hires one worker per step. Hard limits on time, spend and how much can run at once. Checking is part of the work, done by something that didn't write the thing it's checking.
- 04
You approve the result
Finished work arrives as a queue, not an inbox. You see the evidence and the exact version. Approve it and it goes, with a receipt.
Not everything gets the same treatment
Runs freely
Drafts and research. Inert until a person picks them up, so they need no approval at all.
Approved, and undoable
Publishing a page, committing code, changing copy. Always staged, always approved, always reversible.
Recommended only
Money, and anything with no undo. Hub works out what to do and says so. A person does it.
Asking one agent gives you an answer. Wiring an organisation gives you a checked one.
- You ask → it works it out → you get an answerOne step, and whether it is any good is yours to spot.
- You ask → the work is plannedBroken into named steps before anything runs.
- Research, write and build, at the same timeSpecialists, each with one job.
- Someone separate checks itA checker that did not write the work.
- You approveNothing goes live until a person says so.
Eight tools, each holding a piece of the truth, quietly disagreeing.
These are the places your work lives now. Hub is built to be the one place instead, which is only worth doing if it's genuinely all of them.
| Category | What it holds | Tools it stands in for |
|---|---|---|
| Projects & tasks | What is happening, who owns it, what is next | Asana, ClickUp, Monday, Trello, Jira, Linear, Basecamp |
| Sites & pages | Build, publish and edit the client's site | WordPress, Squarespace, Wix, Webflow |
| Review & mark-up | Comment on a page or a video, approve a version | Frame.io, Markup.io, Filestage, Pastel, BugHerd |
| Client portal | Reports, approvals, documents, progress | SuiteDash, Copilot, Moxo, HoneyBook, Dubsado |
| Knowledge & brand | Methods, brand, assets, operating instructions | Notion, Confluence, Frontify, Canva |
Lots of tools do one camp well. We couldn't find one that does all three.
An honest map of the neighbourhood, not a scoreboard. Most of these are good, and we take ideas from all of them.
| Camp | For example | What they have | What they don't |
|---|---|---|---|
| Agent runtimes | LangChain, CrewAI, AutoGen, OpenClaw | The agent, the tools and the graph | No cost ledger per run, no approvals as data, no immutable trail, no records engine. They're personal assistants. You can't put one in front of your accounting system. |
| Records engines | Twenty, Attio, HubSpot | A clean, extensible record, and a good one | Built for people to work in, not for agents to work inside. Nothing governs what an agent may do to an outside system, and none are self-hostable with a worker you own. |
| Automation tools | n8n, Zapier, Make | Steps that fire on a trigger | No durable record of the business, no approval model, and credentials sitting in the workflow instead of behind a broker. |
| Work and knowledge systems | Notion, Asana, Obsidian | The work graph and the knowledge | Nothing runs, and nothing closes the loop back to what the work earned. |
| Agency suites | SuiteDash, Copilot, HoneyBook | The client portal and the delivery workflow | Closed, hosted, no agent layer worth the name, and your data is theirs. |
Hub is the union: a records engine agents work inside, a knowledge layer they read from, a worker you own, and a trail for everything they touched. Nobody sells that as one self-hostable thing today, which is the only reason to build it.
We're building the new core in the open, and you can argue with it as it goes.
Hub runs Agency Astro today. That version grew around one agency, so the open one is being built again properly, as a core anyone can run with our agency setup as the first preset on top. Every decision behind it gets written down, including the ones we got wrong.
The core is free, and copyleft
The platform core goes out under the AGPL. Your database, your hosting, your keys. Anyone running a modified hosted version has to publish their changes, which is what stops a bigger shop closing it and selling it back.
The playbooks stay ours
The skills, automations and presets on top are proprietary and sold with the setup. That's the business. Drawing the line in public beats pretending the whole thing is a gift.
The reasoning is public
The build log says what moved and why. The roadmap says what's still paper. When a decision gets reversed, that's written down too.
Questions people ask first.
The platform core is, under the AGPL. Run it on your own Postgres and your own hosting and it costs nothing. The skills, automations and presets built on top are a separate proprietary layer, sold with the setup work. We'd rather draw that line in public than blur it.
Not yet. Agency Astro runs Hub in production, and the open version is being built as a new core rather than a scrubbed copy of ours, so what ships is something a stranger can actually run. The docs and the roadmap are public now, and the build log says what moved.
Marketing agencies and small teams doing repeatable client work. If you've got a dozen clients, eight tools, one person who has to approve everything, and a growing pile of agent output nobody has checked, that's the shape. The engine is built to be general, but that's the room we know.
To stand up the first release, yes. You'll be pointing it at a database and running a container. Using it day to day needs nobody technical, which is rather the point: the people making the decisions shouldn't have to be the people running the infrastructure.
Whichever one passes the job's tests most cheaply. Big models for the hard reasoning, small ones for triage, and a free local model as the floor. Your keys and your account, and the cost shows up on the job as it runs.
It stays in your database. Hub reaches an outside platform only through a broker, one scoped action at a time, and each one leaves a receipt. Agents never hold a standing key.
The core is free. You're paying for hosting and whatever models you point it at. A reference install is one container plus a hosted Postgres, which as at September 2026 is roughly forty five to seventy dollars a month before model usage, and the local-model floor is zero. If you want our playbooks and the install done for you, that's the paid part.