Agency AI Infrastructure Blueprint
Once your BrandOS works for one person, the next problem is the rest of the agency: who works from which version, who may see which client's context, and what happens to a setup improvement that only one person has. The Blueprint is the kit for the shared infrastructure that answers those questions: the template repositories my own agency runs on, a walkthrough with one short video per component, the decision sheets, the build order with a self-test on every step, and the order to build them in. You build it, and the kit is made so you can. It costs €99, all sales final, bought through the same automated checkout as the Builder. No sales call.
The problem after the BrandOS works
You have the system for building your BrandOS. If you added the Auto-Load Setup, you also have the setup that loads it into Claude without pasting it into every session. Both work for one person.
From one person to the whole agency
What you have
- One home for brand and client context, loading into every approved session
- Roles and access: who sees which client's material
- Controlled connections to the systems you approve
- A shared Skills library everyone installs
- Governance: named owners, an update routine, a review rule
Two systems, the templates from my own agency, and the build order with a self-test on every step.
The state this document is about
A change to your brand or a client's offer is made once, and every session on your team works from it. When a new person joins, the team follows one onboarding workflow for their role, context, access and shared Skills instead of rebuilding a setup from scratch. And an improvement one person builds reaches everyone, instead of staying on one laptop. Whether a change was right is still a person's call; the system only spreads what was saved at the source.
The questions that start once context works
Getting AI to understand your brand is one thing. Getting an agency to work with AI through one consistent, maintainable system is another. Once context works, you start seeing everything around it:
- Who gets access to which client context?
- Where do shared Skills live (the small task instructions your team reuses), so an improvement does not stay on one laptop?
- How do you connect AI to internal systems without opening everything at once?
- How do you update once, instead of chasing every setup on the team?
- And who owns all of this when you are not in the room?
That is the infrastructure layer. Building your BrandOS could not solve it, because it was never a context problem. It is an access, update and ownership problem.
The two systems
System #1: Context Infrastructure
Takes your BrandOS from a document to a working part of your AI environment, for the whole team.
- One shared home for context: the current version of your brand and, next to it, your client contexts, in one place instead of copies on individual laptops
- Automatic loading, so every approved session starts from that context
- One-place updates: a change lands once, at the source, instead of being fixed setup by setup
- The rules for what counts as current, so nobody slides back into private folders
One source, every approved setup
- BrandOS, current version
- Client A context
- Client B context
- A shared Skills library
A change lands once, at the source. The next session on every approved setup starts from it.
The rules name what counts as current and what a private copy is allowed to be. What keeps the slide from happening is a review rule someone on your team enforces, and System #1 has you write that rule down.
If you own the Auto-Load Setup, you have seen the one-person version of this. System #1 is the same mechanism, built so the whole team loads from one source.
System #2: Agency AI Environment
Builds the layer around that context.
- The shared workspace and its rules: where context and Skills live, who works where, and what gets reviewed before it counts
- A roles and access model, so a new person gets the right context on day one and no more than their role needs
- Controlled connections: AI reaches the internal systems you approved, and only those, through one place where every connection is approved
- A shared Skills library, so six prompts for the same task become one maintained version everyone installs
- Governance and maintenance principles: the access, update, review and ownership rules that keep the system useful after month one
Who sees what: a decision someone wrote down
An illustration of the shape, not anyone's real table. The point: "who can see this client's material" has an answer without checking laptops.
Connections go through one door
Six prompts become one Skill
Someone improves the way a task is done. The improvement has a route to everyone instead of staying on one laptop.
Rules on a page keep nothing maintained by themselves; the owner named in them does. The last step of System #2 is naming that owner on your team, and the rules hold only as long as that person holds them.
The order
Context first, then the environment around it, with governance as the last step of System #2. Each layer stands on the one before it: access rules over context that still lives in private copies are paperwork. The Blueprint lays the systems out in that order, and each step ends with a self-test, so you know it holds before you build the next one on top of it.
Two systems, in this order
- One shared home for brand and client context
- Loading into every approved session
- Update logic: a change lands once
- The rule that says what counts as current
- The shared workspace and its rules: where things live, what gets reviewed
- Roles and access
- Connections through one approval point
- A shared Skills library
- Governance: owners, update, review. The last step.
Each layer stands on the one before it. Access rules over context that still lives in private copies are paperwork.
What you open
Every item below is one of four things: a template you copy, a walkthrough you follow, a decision sheet you fill in, or a self-test that tells you the step holds. There are seven components, and each comes with one short video and a page of text: what it is, which decision it encodes, and how you check that it runs. The build order gets an eighth video.
System #1: Context Infrastructure
- Brand repository and client-repository templates to clone, with the README that states what counts as current and the review rule as a pull-request requirement (template)
- Team loading for Claude Code and Cowork, so every person on the team loads from the shared home (walkthrough). Change one fact at the source; a colleague's next session shows it (self-test)
- The update routine on one page: change, check, merge, next session (walkthrough)
System #2: Agency AI Environment
- The roles and access table, one row per access decision, with the default and the trade-off next to it (decision sheet). Setting it up as a GitHub organisation with teams and repository rights (walkthrough)
- The portal, the one place in your Cloudflare account where every connection between your AI and an internal system is approved and passes through: its code (template). Deploying it into your Cloudflare account (walkthrough). The connection approval sheet: connection, job, owner, approved by, date (decision sheet). One connection passes through the portal, another does not (self-test)
- The plugin scaffold with one real Skill from my own system (template). The routine that turns six prompts into one Skill (walkthrough). One Skill installs from the plugin on two setups (self-test)
- The governance page from my own agency, with the owner fields, the update workflow and the review rule (template). The onboarding checklist for the next person (template)
Across both: the build order as a checklist with a self-test on every step, including the steps that have none listed above (walkthrough plus self-test).
You open all of it in a login area on csauerborn.com: the files to download and the videos, one per component. No community, no forum.
Two of the templates, as they exist in my own agency today:
Your first afternoon
Clone the brand-repository template, put your BrandOS in it, and run the first self-test: switch on the loading for yourself, then ask a session something only your BrandOS knows. That is System #1 for one person, and it is where the kit starts. If you own the Auto-Load Setup, you have done this once for your own structure; the walkthrough shows where the shared repository takes its place. The second afternoon adds the second person.
Three of the decisions you will answer
- How to split the repositories. GitHub grants read access per repository, not per folder. So "who may see which client's context" is a repository decision: a brand repository plus one repository per client, or one repository where everyone sees everything. The sheet states the default and what each choice costs you.
- Who approves the next connection. Every connection between your AI and an internal system exists because someone decided it should. The approval sheet asks you to name that someone before the first connection exists.
- Which client contexts move into the shared home, and who owns each. The structure has a slot for every client; the decision is which ones go in first and who keeps them current.
Not in the kit
No method for extracting client contexts (your team builds them the way you built your BrandOS), nobody on my side who checks your build, no support, and no walkthrough for any environment other than Claude Code and Cowork.
Building it, in plain words
What you build, and what you decide
You build it with your own hands, or with whoever on your team owns your setup. It is real technical work: the infrastructure lives in your own accounts (GitHub for the shared home, Cloudflare for the connections), and there is a run of decisions that are yours to make. Which client contexts sit in the shared home. Who gets which access. Which connections you approve, and who approves the next one. The kit gives you each decision as a sheet with the default and the trade-offs laid out, and the templates give you structures to fill in rather than invent. Making the decision, doing the work behind it, and checking it holds stays with you. Nobody on my side checks your work.
What the price does not include
Nothing in the price is support. There is no Slack channel and no session; the kit is the product. You can reply to any of my emails and I read every reply, but I am not promising build support at €99, and I would rather say that here than have you expect it after checkout.
Where it starts
It starts from your BrandOS. The first thing the Blueprint does is give it a home for the whole team, so have a usable first version before you start building. If yours is still half-built, finish that first.
The environment it is written for
The standard setup is Claude Code and Cowork, which is what my own team runs. The automatic loading, the shared Skills structure and the connection setup in the Blueprint are written for that setup. If your team runs Codex, ChatGPT, Hermes or OpenClaw, the shared home and the context structure carry over; the loading, the Skills and the connections you adapt yourself, and the Blueprint does not walk you through those environments.
The price
€99, one price for both systems. It is the same price the Blueprint had at the one-click offer after your Builder purchase. There was no discount then, there is none now, and there is no deadline on this page. All sales are final, same as the Builder. Checkout shows the VAT for your country before you pay.
This is the architecture I run inside my own agency. There are no client case studies behind it. My own working system is the whole proof. Bought here, the Blueprint is the standalone kit for a team that builds itself. Agency AI Infrastructure — Install ships with these same files; if you buy the Install later, the €99 is not credited.
Before you buy
There is no salesperson here, so this block does the qualifying.
This is for you if:
- Several people in your agency do client work, and AI is already part of the daily delivery
- Your BrandOS exists, built with the Builder or otherwise
- Someone on your side can own the accounts the infrastructure lives in (GitHub and Cloudflare), and will do the technical work
- You want to understand the architecture and build it in your own time
Do not buy this if:
- Your BrandOS does not exist yet. Build it first; everything here stands on it.
- You want the system installed on your accounts and handed over instead of building it from the kit. That is Agency AI Infrastructure — Install, laid out in its own document, and it ships with these same files. Same system, two routes: one you build, one I build and hand over. Separate purchases, prices independent, and you do not need this one first.
How to buy
- Click the checkout button below and complete the checkout. It works the same way your €9 purchase did.
- Access arrives by email right after.
- Start with the build order and the brand-repository template. Your BrandOS gets its home before anything is built around it.
One-time payment. All sales are final. Checkout shows the VAT for your country before you pay.
In a nutshell
The shared home for your brand and client context, and the environment around it, built by you from the templates my own agency runs on, with a walkthrough and a video per component and a self-test on every step of the build order. €99, all sales final.