The company in this story is Hulken, where Northstone built and runs the operating system described here.
People ask us the same question when they hear the numbers: a consumer brand doing more than $50 million in revenue, run by a team of seven. How?
The answer they expect is a list of AI tools. It isn't. We didn't get here by buying more software. We got here by changing how the company runs, and then putting AI on top of that.
Here is what that means, layer by layer.
The problem was never effort. It was coordination.
As the company grew, the work itself didn't get harder. Keeping everyone aligned did.
Product launches, inventory planning, retailer conversations, marketing campaigns, customer questions, vendor communication, and operational projects were all happening at once. Information lived across Slack, spreadsheets, email, our storefront, our analytics, and meetings. Nothing was broken. But every decision required someone to go find the context, and every handoff was a chance for something to fall through.
That is the tax that quietly caps a growing company. Not the work. The coordination around the work.
Adding people relieves it for a while, then reintroduces it at a bigger scale. We weren't looking for AI. We were looking for leverage. And leverage, it turns out, comes from a system, not a headcount.
An operating system has three layers, built in order
The mistake almost everyone makes is to start at the top, with the AI, and skip the two layers underneath. Those two layers are the entire reason the AI works.
- 01
One source of truth
Before any automation, we built a clean, connected place for the company's information to live. Clients, projects, products, inventory, deliverables, and the relationships between them, with the underlying data made trustworthy first. This is the unglamorous step, and it is the one that matters most. An agent built on scattered, half-accurate data inherits the scatter and the inaccuracy.
- 02
Workflows redesigned around how work really happens
We rebuilt the routes work travels, around how the work really moves, not how an org chart says it should. Where does a product idea go once someone has it? How does an inventory signal reach the person who acts on it? We wrote those paths down and built them into the system, so the route stopped living in people's heads.
- 03
AI on top
Only then did we add intelligence: a network of specialized agents, each responsible for one slice of the business, each with clearly defined instructions and boundaries. Not one general assistant trying to do everything, but a set of narrow, reliable operators.
One small decision turned out to matter more than we expected: we give each agent a name and a role. It sounds trivial. It became one of our best adoption levers. People naturally think in terms of "ask the ops agent" or "route this to the product one," the same way they'd delegate to a colleague. A named role is easier to trust, and easier to hand work to, than a generic automation.
The queue that ties it together
At the center of the system is a simple idea borrowed from good operations, not from AI: a queue.
Every request follows the same path. Captured, assigned, executed, completed. Each item has exactly one owner, and work is routed to a specific agent based on a defined roster and responsibility model, rather than relying on someone noticing a message and deciding to pick it up.
A retailer emails about a delayed shipment. The request is captured, routed to the agent that owns logistics, and lands with a draft reply and the tracking context already attached. A person approves it, the loop closes, and the record of what happened stays in the system instead of in someone's inbox.
That single discipline, one owner per item, no orphaned work, does more for a lean team than any individual automation. It means nothing depends on memory, follow-up messages, or tribal knowledge.
What it looks like in practice
Four examples from inside the system:
- Routing work across functions.A request comes in, gets logged, gets assigned to the right agent, gets executed, and gets closed with a note. The goal was never to automate every task. It was to create a documented, reliable path for ownership and execution.
- Keeping records whole.In product development, the value is in the relationships between projects, products, timelines, and vendors. A common failure mode is incomplete records, a product with no parent project, a project with no product, that quietly break reporting later. The system prevents those gaps at creation, not afterward.
- Speaking one language about inventory.Different teams used to mean different things by the same word. So we standardized the definitions, available versus on hand versus committed, along with the rules for how each channel is reported, including the rule that separately managed channels are never summed together. Everyone now reads the same numbers the same way.
- Surfacing what crosses teams.The classic failure is that something becomes known inside one team and never reaches the team that needs to act on it. So the system captures cross-team flags and routes the actionable ones back into the queue, where they get an owner, instead of dying in a summary.
The part that made it work
None of this would have mattered if people didn't use it. So the design centered on the humans at the desk, not the elegance of what was behind them. Two principles did the heavy lifting.
People stay in control. The agents surface information and draft the next move, the email, the update, the plan. A person reads it, judges it, and decides. The send button is always theirs. Used this way, AI is a force multiplier for judgment, not a replacement for it, and that is exactly why the team trusts it enough to rely on it.
Everything closes the loop. Work gets recorded, measured, and fed back, so the system can see its own output and improve. A company that can't see how its own work flows can't improve it, and neither can its AI.
What we learned
The most valuable thing we built isn't an agent. It's the operating system around the agents. The workflows. The ownership. The source of truth. The mechanisms that move information through the company without a person having to carry it.
The results are simple to state. Decisions that used to take a week of chasing context now happen in a day, often in hours. The team is still seven people while the company scales toward $100 million. Nobody was replaced. Everybody got leverage.
Not a bigger team. Not a better model. A system that does the coordinating, so the people can do the deciding.
What it means for your company
If you're trying to do more with a lean team, the instinct is to reach for another tool. We'd suggest the opposite. Fix the process, build the source of truth, redesign the workflows, and then put AI on top. The tool was never the constraint. The operating system underneath it was.
That's the work we now do for other companies. If you want to see where yours is losing time, and where an operating system would give you the most leverage, that's a short conversation away.
For the framework behind this, read The 90% Problem.