Running three brands from one set of automation tools sounds efficient until a draft written for one audience lands in another brand's queue. The useful question is not how many brands one agent can handle. It is which parts should be shared, which parts must stay separate, and where a person checks the work before anything goes out.
This article describes an example design. The three brands in it are invented: a bike repair shop, a trail-riding newsletter, and a bookkeeping service for small businesses. The article is not a description of anyone's live setup, and it reports no measured results. Treat it as a sketch to adapt to your own accounts, risks, and tools.
Pick one unit of isolation
Choose a single identifier, call it brand_id, and make it travel with every job. Everything that differs between brands hangs off that identifier. Everything that does not differ lives in shared code.
Shared across brands:
- The scheduler or job runner that starts work.
- The wrapper around the model API, including timeouts and retry rules.
- The run log format.
- The code that implements a review queue.
- The validators that check a draft before it is queued.
Separate for each brand:
- Voice rules and a list of claims the brand may not make.
- Source material the drafts are built from.
- Credentials for any outside account.
- The review queue and the person who approves it.
- A spending counter.
This split follows a principle from the Twelve-Factor App: anything likely to vary between deploys belongs in configuration, strictly separated from code. Each brand behaves like its own deploy of the same code. The same page offers a useful test for credentials: could you publish the codebase today without exposing a secret? If not, a secret is sitting in code.
Write the brand profile as data
A profile is a small file that the shared code reads at the start of each job. It holds no secrets, only the names of where secrets live.
brand_id: trailnotes
display_name: Trailnotes newsletter
voice_rules:
- Plain, second person, short sentences
- No claim about trail conditions unless a source note supports it
banned_phrases: ["guaranteed", "best in town"]
input_dir: inputs/trailnotes/
credentials_ref: env:TRAILNOTES_API_TOKEN # the name of a secret, never its value
review_queue: queues/trailnotes/
approver: one named person
budget_counter: spend/trailnotes
The figure above shows why each line exists. The bookkeeping brand would carry stricter banned_phrases, such as anything that sounds like tax or legal advice, and a narrower set of sources. That difference lives in its profile, so tightening one brand never loosens another.
One job, six steps
This design is a workflow in the sense used in Anthropic's guide to building effective agents: language models and tools orchestrated through predefined code paths, not a model that chooses its own steps. That guide recommends finding the simplest solution that works and adding autonomy only when it earns its cost. For three brands with known tasks, a fixed path is easier to test and easier to explain to the person who approves the output.
A job runs like this:
- The trigger names a
brand_id. A cron entry or a manual command supplies it. - The runner loads that brand's profile. If no profile exists, the job stops. It does not fall back to a default.
- The runner reads only that brand's input directory.
- The model client receives the voice rules and the inputs and returns a draft in a fixed schema.
- Code checks the draft: the brand stamp matches the job, banned phrases are absent, and length is in range.
- The draft goes to that brand's queue, marked
pending_revieworneeds_edit.
The following pseudocode assumes profile and draft objects, a trusted input loader, and separate queues. It illustrates the boundary checks rather than a complete application.
def run_job(job, profiles, queues, model):
profile = profiles[job.brand_id] # a KeyError stops the job
inputs = read_inputs(profile.input_dir)
draft = model.draft(profile, inputs) # stamps draft.brand_id from the profile
if draft.brand_id != job.brand_id:
raise ValueError("draft was built from a different brand profile")
problems = find_banned(draft.text, profile.banned_phrases)
status = "needs_edit" if problems else "pending_review"
queues[job.brand_id].add(draft, status=status, problems=problems)
The check in the middle looks redundant until someone refactors the loader and a cached profile leaks across jobs. It is cheap, and it turns a silent mix-up into a loud error.
Keep credentials narrow, and start without posting rights
The OWASP entry on excessive agency names three root causes: excessive functionality, excessive permissions, and excessive autonomy. Its prevention advice applies directly here. Give each integration the minimum permissions it needs, run actions with the identity of the specific user or account involved, and require a person to approve high-impact actions. The page uses a social media posting step as one of its examples of where approval belongs.
For three brands that means three separate credentials, each limited to one account. A single token that can reach all three accounts turns one wrong brand_id into a post on the wrong audience. The safest starting point is a system with no posting credential at all. It writes drafts to a queue, and a person publishes by hand or through a separate, separately permissioned tool. Add posting later for the brand where the review habit has proven itself. The agent security guide covers the wider threat list.
Give each brand its own review queue
A combined queue can make brand mix-ups harder to notice. When drafts from three brands sit in one list, approving quickly means reading a brand label and trusting it. A separate queue per brand, each with a named approver, makes the context obvious before the draft is read.
If a single person approves everything, keep the queues separate anyway and give the owner a read-only digest that lists counts and ages per brand. The digest answers "is anything stuck?" without inviting bulk approval.
The same reasoning applies to anything the system remembers. If you add retrieval or long-term memory, use a separate store for each brand instead of one shared index with a brand filter. A filter works only if every query remembers to apply it. Separate stores remove that dependency. The memory guide explains the storage options.
Decide component by component
The tree above is a quick way to classify a new component. Anything that holds voice, claims, or customer data stays per brand. Anything that acts on an account a brand owns uses shared code but a per-brand secret. Anything whose bug would hurt all brands at once is shared, but changes to it roll out to one brand first. The rest, such as a scheduler or a log formatter, is shared freely.
Failure modes to design for
- Wrong profile loaded. Covered by the stamp check and by refusing defaults.
- One brand's failure blocks the others. Run each brand as its own job so a timeout in one does not stop the rest. The retry guide explains which failures to retry.
- Profile edited mid-run. Load the profile once at the start and record its version in the run log.
- Approver overload. If drafts pile up unread, reduce volume rather than loosen review.
- Cost surprises. Count spend per
brand_idfrom the usage figures your provider reports, and set a cap per brand. Include retries and manual review in that budget, and compare it with the task's value. - Blind spots. Log
brand_idon every run so you can filter. The monitoring guide describes a run record that does this.
Limits of a shared stack
Sharing code saves repeated fixes, but it couples your brands. If the brands have different owners, different legal entities, or different compliance duties, separate deployments are safer than separate profiles. The bookkeeping example above is the likeliest candidate. Platform rules also differ by site, and an account that allows manual posting may restrict automated posting, so check each platform's terms before connecting anything.
This design also says nothing about draft quality. Whether the drafts are any good depends on your inputs, your model, and your reviewers, and you should measure that by sampling outputs, not by assuming it.
Build a small first version
Build it for two brands, not three. Write two profiles and one small fixture input directory for each. Run both jobs. Then deliberately break it: pass a brand_id with no profile, swap profiles between jobs, and confirm each mistake stops the run before anything reaches a queue. If you have not built a single-brand worker yet, start with the first-agent guide, then return here. For coordination across several agents, see orchestration. The monitoring guide explains run records and freshness checks.
For the lab's broader implementation work, see Creative Claw. This guide stands alone and does not depend on it.
Sources
- The Twelve-Factor App, Config: config that varies between deploys is kept apart from code.
- Anthropic, Building effective AI agents: workflows versus agents, and starting with the simplest approach.
- OWASP GenAI, LLM06:2025 Excessive Agency: minimum functionality and permissions, plus human approval for high-impact actions.


