Creative Marketing OS
Provider-agnostic creative production architecture combining governed brand context, structured campaign workflows, image and video production, human review, and reusable delivery pipelines — a system of record and policy engine, not a content generator.
01Overview
The system of record and policy engine for client creative work. It turns governed client knowledge into brand-safe, multi-channel campaigns, operated conversationally through an agent, and it improves from every approval decision through a defined learning loop. The design premise is that the hard part of creative production at scale is not generation — it is governance.
02Problem
Generating marketing content is a solved problem and nearly worthless on its own. The expensive failures in agency-style work are governance failures: one client's confidential material informing another's campaign, brand rules that live in someone's head, content published that nobody senior actually approved, and reviewer corrections that get applied once and then forgotten, so the same mistake is made every month. None of these are fixed by a better model.
03David's role
- Designed the domain model, isolation capability, campaign graph, approval framework, and learning standard.
- Established the architectural rule that the core contains no model calls and cognition arrives through a generated agent skill.
- Built the typed port and adapter layer so channels and sibling systems are replaceable behind contracts.
- Authored the Closed-Loop Intelligence Standard governing how reviewer decisions become durable improvements.
- Wrote the adversarial isolation tests that keep the client-separation guarantee true.
04Architecture
A deterministic core of domain entities, lifecycle machines, and invariants, wrapped in typed ports. Every piece of client data lives inside a client workspace that fails closed across boundaries. Channels and sibling systems sit behind adapters. An agent operates the whole thing through a generated skill that uses the same command tree and passes through the same gates as a human operator.
05How it works
- 01Capture
- 02Signal
- 03Score
- 04Produce
- 05Review
- 06Publish
- 07Learn
- 01
Capture
Client knowledge enters as sectioned, typed, provenance-carrying facts in two separate stores: a Business Brain and a Brand Brain.
- 02
Signal
Events from sibling systems — listing launches, revenue signals, deals won and lost — arrive as opportunity signals.
- 03
Score
An opportunity engine scores signals with explainable reasoning and promotes the strongest into campaign arcs.
- 04
Produce
Campaign arcs generate content through the campaign graph, checked against the Brand Brain's compliance rules.
- 05
Review
Content goes to human review, where a reviewer approves, edits, or rejects. Nothing publishes without passing this gate.
- 06
Publish
Approved content publishes through channel adapters, which re-verify the approval gate themselves rather than trusting the caller.
- 07
Learn
Reviewer edits are distilled into proposed learnings, which are themselves approved before being applied to the Brand Brain, then monitored.
06AI & technology
- Agent-operated through a generated skill exposing the same command tree available to humans
- Brand compliance checking against versioned, governed brand rules
- Explainable opportunity scoring — a promotion decision can be inspected, not just trusted
- Closed-loop learning: capture, distil, propose, approve, apply, monitor, audit
- Ports for service-side generation and distillation defined for later phases
07Integrations
- Channel adapters for Instagram, Facebook, LinkedIn, and YouTube behind typed ports — mocked in the current phase by design
- Sibling system ports for listing-launch events, revenue signals, and creative operations briefs
- Company playbooks flow inbound only; nothing derived from client data flows up or across
- A JSON command mode so agents and humans drive the same interface
08Human control & governance
- Client isolation is structural: cross-client access fails by construction, with adversarial tests holding the line.
- Nothing publishes, no brain changes, no opportunity is promoted, and no learning is applied without passing the single approval framework.
- The publish gate is re-verified inside the channel adapter itself, so a caller cannot bypass it.
- Events, signals, observations, brain history, and the publish ledger are append-only; corrections supersede rather than rewrite.
- The learning loop is client-scoped and auditable by command, so improvements cannot silently cross client boundaries.
09Key design decisions
The decision, the alternative it was chosen over, and why.
- 01
Decision
Allow no LLM calls anywhere in the core source tree; cognition arrives through a generated agent skill.
Instead of
Calling models directly from the services that need generation.
Why
It keeps the entire system deterministic and therefore genuinely testable — invariants, isolation, and approval logic can be verified without a model in the loop or a mock pretending to be one. It also makes the model a replaceable participant rather than a dependency threaded through every service.
- 02
Decision
Re-verify the publish approval gate inside the channel adapters themselves.
Instead of
Checking approval once in the service layer before dispatching to the adapter.
Why
The adapter is the last point before content becomes public and irreversible. A single upstream check is one refactor away from being bypassed; checking again at the boundary means a mistake in the calling path fails safe instead of publishing to a client's real audience.
- 03
Decision
Make client isolation structural rather than a rule that queries must be scoped.
Instead of
Filtering by client identifier at the data-access layer.
Why
Filtering depends on every future query remembering to filter. In agency work a cross-client leak is a business-ending event, so the guarantee has to hold by construction and be defended by tests that actively try to break it, rather than by everyone being careful forever.
- 04
Decision
Route reviewer edits through a formal learning loop that is itself gated by approval.
Instead of
Feeding corrections back into brand context automatically as they occur.
Why
Automatic learning from edits will faithfully learn one reviewer's rushed Friday afternoon and encode it as brand policy. Making a learning a proposal that a person approves — then monitoring it after application — is what separates a system that improves from one that drifts.
- 05
Decision
Ship Phase 1 with every channel adapter mocked, and say so in the first paragraph of the README.
Instead of
Connecting one real channel to demonstrate genuine end-to-end publishing.
Why
The valuable and difficult work is the isolation, approval, and learning architecture; a live channel would have proved much less and implied the whole system was operational. Building against contract-tested mocks kept the ports honest, and the status is stated where nobody can miss it.
10Tradeoffs
- A deterministic core is fully testable and cannot generate anything by itself — generation quality depends entirely on the agent operating it through the skill.
- Structural isolation makes any legitimate cross-client capability, such as agency-wide analytics, genuinely hard to build later. Accepted deliberately.
- Approval on every mutation — publishing, brain changes, promotions, learnings — is heavy for a small team and is the property the system exists to provide.
- Mocked adapters mean the contracts are proven and live channel behaviour is not; Phase 2 will surface real-world API behaviour the mocks cannot anticipate.
- Append-only history with superseding corrections costs storage and makes reads more complex than mutable records would.
11Outcome
The Phase 1 foundation is complete. A single demo command exercises the entire closed loop: create a client, seed both brains through approvals, ingest sibling events, score and promote a campaign arc, run content through review including reviewer edits and a rejection, publish through mocked adapters, distil the edits into a learning, apply it to the Brand Brain, monitor it, and finish with a clean audit. Unit, contract, isolation, and end-to-end suites cover it. Live channel connections are Phase 2 and are described as such.
12Evidence
- Runnable closed loop
- A single seeded demo command drives the full lifecycle end to end, including a rejection and a reviewer edit that becomes an approved, applied, monitored learning.
- Test structure
- Separate unit, contract, isolation, and end-to-end suites, with adversarial tests specifically defending client isolation.
- Written standard
- The Closed-Loop Intelligence Standard is documented as mandatory and enforced by an audit command.
- Stated phase status
- The README states in its opening that all channel adapters are mocks by design, with no live social connections.