It is Thursday of a heavy week, three project calls deep, and someone asks who Anita is and why she is down as a participant in the next project meeting. The people in the room are not sure. The one who might know is on vacation.
That small blank is not a production problem. It is the everyday tax of any company that runs several projects with real teams. Most of a working week does not go to the work itself. It goes to coordination: passing information along, handing off results, flagging problems, making sure the right person knows the right thing before it is too late. One widely cited study of knowledge work puts close to 60 percent of the average day here, on communicating about tasks and hunting down context, and only a quarter on the skilled work people were hired for. And that coordination breaks all the time. Someone was not looped in, a decision fell between two calls, the context lived in one head and that head is on vacation. The cost lands in three places at once: on the creative vision, which drifts when half the team is working from an old version of it; on the people, who spend their days doing archaeology instead of their craft; and on the money, because all of that is time, and time is the budget.
What is changing is that this coordination layer can now be run by AI, and run well. We are one of the first production companies in the country to build the business AI-first, the office itself rebuilt around AI instead of AI bolted onto a traditional one. So this is not a piece about AI on the screen, where most of the conversation sits. It is a concrete account of the other thing: how we run the company's actual processes on AI, what the office now does on its own, and where a person still has to stand.
What we actually built
The goal was blunt. We wanted to run the whole company, operations, marketing, and production, on a deliberately lean team, and let none of the three go soft because of it. The usual way to hold all that together is phone calls, long email chains, and meetings, which is how most of the industry still works, especially here in Germany. It holds until it does not, because producing is a process where creative vision and economics are braided together and every decision needs a lot of context to get right. We built something else: a single AI root, one shared memory and one set of rules that every part of the office grows out of.
So six months ago we started moving that coordination layer onto AI, and kept one rule the whole way. Automate the work, not the judgment.
What we built is an operating layer that runs across the whole office. It keeps a living map of every project, turns the day's calls and chat into tracked work, and lets a set of specialist roles read from one shared memory and push their results back to wherever each belongs: the project folder, the task board, the website. Above them sits what amounts to an AI chief of staff that holds the company's strategy and, reading the board against it, flags which tasks actually move the company and which are just noise. Even the piece you're reading came off the same layer. It works from the company's own files instead of a blank page, drafts from them, and then waits for a person to approve it before it goes anywhere.
But drawing that line is the hard part. Give an AI a task with clean inputs and one right answer and it is remarkable, fast and tireless. Give it one that turns on judgment, who to believe, what to promise, which number is wrong, and it fails while looking confident. So the real work is not automating as much as possible. It is finding the exact point where the machine should stop and hand back to a person. That line is the whole design, and it is why a person still signs off on the paragraph you just read.
What follows is what we built, in plain terms, with the parts that still break left in.
What the office does on its own now
Calls become organised work
Every work call we host is processed the same evening, without anyone taking notes. The transcript is picked up, a summary is written, and from there the system sorts the call into the project it belongs to and acts on it. If that project already exists, it folds the new material into the project's map: the fresh commitments, the updated tasks, the changed details about the client and the deal. If the call is a new project or a first brief, it builds the map and fills it with the first pass of everything the conversation revealed.
The important part is not the transcription. Off-the-shelf notetakers transcribe fine. The important part is that our layer knows which project the call belongs to and reads that project's history before it writes a word, and it does that without being told. Nobody tags the call, uploads the back-story, or points it at the right folder. The system works out what already exists, matches the call to the project it belongs to, and links the people and threads on its own. So a call is not handled as a fresh, standalone event. It is handled as the fourth conversation on a project, read in light of the first three. The output is not notes about a meeting. It is a project, updated.
The project map, not a to-do list
That map is the document a new freelancer reads instead of sitting through a thirty-minute retelling. It holds what the project is and what success means, what is in and out of scope, the deadlines and commercial terms as discussed, and the risks raised on the call. It pulls the strategic tasks and first steps too, each carrying the exact quote it came from, so every task traces back to a sentence someone actually said. The map is living. Every later call edits the same document instead of starting a new one.
One board, many hands
Approved tasks land on a single shared task board, the one place the whole team reads. They arrive there without anyone typing them in. Tasks come off calls once a human approves the summary, and tasks come out of chat when someone writes a short instruction that the system turns into a card for a one-click confirmation. And the specialist roles do not only read that board. Each writes its own results back to where they belong: a marketing plan into the marketing space, a processed call into the project folder, a drafted article into the content pipeline. One memory in the middle, many hands reading from it and writing to it, none of them working off a copy that went stale the moment it was pasted somewhere.
A chief of staff over the agents
One layer up sits what amounts to an AI chief of staff. It does not run headless the way the pipelines do, it works when one of us opens it, but when it runs its job is to keep the work from drifting. It reads the open tasks and decisions against where the company has actually chosen to go and flags whatever has wandered off strategy. It reviews the output of the narrower agents beneath it, so no single role runs unchecked. And together with an AI marketing lead it does more than coordinate: it forms hypotheses, runs them, and reads the result. That muscle is trained on marketing for now, where we already run a fixed method for turning a hunch into a tested experiment. The next step is to point the same method at the research-and-development end of production, where the questions are which formats and which ideas earn a real budget.
The whole staff comes to this. A chief of staff, a marketing lead, an architecture role, one per part of the business, a small org chart made of software. The honest limit is worth saying out loud. The routine pipelines run on their own on a schedule; the judgment-heavy roles, this one included, run only when one of us opens them. We have built the operating system and the org chart for an office that runs itself, and the plumbing already does. We are not claiming a company that operates while everyone sleeps.
How the office ran before this
Before, it ran on two things. One was discipline: a producer wrote the summary, opened the tasks, and carried the follow-ups in their head, until a heavy week came and the writing-up quietly did not happen. The other was an AI notetaker, good at exactly one thing, summarising the call in front of it, and blind to the project around it. Both give you a record of a meeting. Neither gives you a running record of a project. The difference is persistence. A summary is a snapshot. An operating layer is a memory.
What this means for a producer
More projects on the same team
The pitch is not fewer people. It is the same people spending their hours on the work that needs them, casting, story, clients, the deal, instead of on the admin that clusters around it. The admin after a single call, the summary, the tasks, the file update, the follow-up you have to remember, is realistically twenty to forty minutes done properly. Treat that as an honest estimate, not a figure off a dashboard. The point is not one number. It is that this tax is paid after every call, on every project, every week, and it is the first thing dropped when things get busy. Multiply it by your own call volume. That is the coordination tax, paid in full, every week.
The whole team holds the same picture
The bigger win is not the minutes saved on any one task. It is that the context stops living in people's heads. At any moment, anyone on a project can open its map and see the same thing: what the client wants, what was promised, what changed on the last call, what is still open. Creative vision and commercial reality sit in one place, so they stop drifting apart between the people carrying them, and nobody is building against a version of the project that went stale a week ago.
And because the same layer holds both the intent and the tasks, it ties them together in a way that was not possible before. A decision made on a call does not just get written down. It becomes the work that carries it out, each task traceable back to the sentence that created it. The gap between what was agreed and what actually gets done, the gap where projects quietly lose themselves, closes to almost nothing.
The handoff is the whole trick
The automation upstream is the easy part: detect the transcript, write the summary, route it to the project, draft the tasks. The machine does all of it well and does it every time. The value is not there. It is in knowing exactly where the machine has to stop, and it has to stop because it has one dangerous habit. Automatic transcription mishears names and numbers often enough that you cannot trust it blind (independent testing puts speaker-attribution error in ordinary overlapping conversation in the ten to twenty percent range), and it never looks unsure while getting them wrong.
So there is exactly one required human touch, at the single point where a confident wrong answer would cost real money. Before anything becomes a task, the person who owned the call checks four things: the names, the money, the deadlines, and who decides. Everything else is automatic.
The skill is not automating everything. It is knowing the exact moment to hand the work back to a person.
The approval step is not friction we failed to remove. It is the point.
The list we gave ourselves
If you were setting this up, start where the leak is largest and the judgment is smallest. Post-call write-up is the obvious first candidate, high-volume, low-creativity, and the first thing to slip. After that, keep to a list. This is ours, in roughly the order we would build it again.
- Automate the write-up, never the judgment. Hand the machine the summary, the task drafting, the filing. Keep for a person the decision about who to trust, what to promise, and which number is right. If you cannot tell which side of that line a step sits on, treat it as judgment and keep it.
- Put exactly one human gate, and put it where a wrong name costs money. Not five checkpoints, one, at the moment a draft becomes a commitment to a client and nowhere else. Before any task goes live, the person who owned the call checks four things: the names, the money, the deadlines, and who decides.
- Keep a living project map, not a pile of meeting notes. A summary is a snapshot; you need a memory. Route every call to the project it belongs to, read that project's history before writing a word, and update one document instead of starting a new one. Call four should be read in light of calls one to three.
- Feed one board, and never hand-type a task onto it. Tasks should arrive off the call once a human approves it, and out of chat with a single click to confirm, never by someone retyping them. Five copies of the task list is the same as no list at all.
- Trust the machine to hear the meeting, not to know the project. Off-the-shelf notetakers are good at the one thing they do, summarising the call in front of them. They do not carry the project across calls or reconcile today against what was promised a month ago. Buy the transcription, build the memory yourself.
- Assume the transcript is confidently wrong. Automatic attribution mishears names and numbers often enough that a misheard speaker becomes a misassigned task, and it never looks unsure while doing it. That is the whole reason the one gate exists: the machine's most dangerous failures are the ones that look certain.
- Make the filing legible before you automate on top of it. An AI layer is only as reliable as the documents under it. Give every file one status and one home, let a draft become canon only when a human says so, and keep one document per topic instead of a drawer of near-copies. We learned this the hard way. Renaming a single field once quietly broke the bridge that files our tasks, and no error appeared until a person noticed they had stopped arriving.
- Build the org chart, but say out loud what actually runs unattended. The routine pipelines run on a schedule with no one watching. The judgment-heavy roles run when one of us opens them. Claim the operating system and the self-running plumbing, because both are real. Do not claim an office that runs itself while everyone sleeps. The honest version is the one a producer actually believes.
The goal was never AI that makes the creative decisions. It was AI that clears everything standing between us and making them.
Where this leaves us
The call still ends the same way. The difference is what happens in the hour after it. The summary is written, the project file is current, the tasks are on the board with the sentence that created them attached, and the one thing left for a person to do is read it and say yes. The coordination tax is still there. We just stopped paying most of it by hand.
If your office looks like the busy-week version, where the writing-up is the thing that never happens, that is the part worth starting with. It is a shorter thing to set up than it sounds.
---