We Gave the AIs Jobs: Inside Our Marketing Operating System

In the first part of this series, we described how Endertech’s attempt to build a self-improving marketing system turned into a supervised operating model. Specialization won over the monolith. This article is about what that looked like once the question changed from “Which AI should run marketing?” to “What is each system allowed to own?”

Once several AI and marketing systems became useful, capability stopped being the hardest design problem. Responsibility was. Who owns strategy? Who gathers evidence? Who may execute? Which system is authoritative for each fact? When must a human decide?

We answered those questions by writing job descriptions for systems the same way serious teams write them for people.

The job-description model

Every useful system in the operating model now has, at minimum:

• a bounded role

• expected inputs

• expected outputs

• authority limits

• source-of-truth rules

• an escalation path

That sounds managerial because it is. Connecting tools is easier than deciding who is allowed to believe what, decide what, and change what.

Two principles sit underneath the rest:

• Strategy is centralized; execution is distributed.

• Each fact has one authoritative source. Shared artifacts may summarize that fact, but they do not replace the source.

ChatGPT: AI-CMO strategy and interpretation

ChatGPT owns marketing objectives, portfolio allocation, positioning, paid-media strategy, website and CRO strategy, blog and newsletter strategy, social editorial strategy, cross-channel interpretation, executive reviews, and high-impact recommendations.

It should not become the high-frequency collector, the routine content factory, or the everyday campaign operator. Those jobs consume the attention that strategy needs.

In practice, ChatGPT’s daily value is triage and judgment: convert overnight evidence into a small number of Continue, Change, Test, Stop, or Escalate decisions, each with evidence, an owner, and a review point.

Grok Bot: operations coordinator

Grok Bot owns scheduled evidence collection, normalization, operational monitoring, handoffs, tactical research, authentic-content discovery and draft production, creative coordination, and orchestration of approved execution.

Important boundary: Grok Bot does not currently have direct ads-management connectors. Approved ad-platform changes are routed through Ryze. Grok Bot may direct Ryze or Cursor Cloud Agents only after a decision record contains explicit approval and acceptance criteria.

That is the difference between an operations coordinator and an unsupervised operator.

Ryze: SEO/AEO operations and approved ads execution

Ryze owns recurring keyword and AI-prompt monitoring, technical SEO operations, managed off-site work, its search-coverage content lane, and its own content and placement records. It is also the ads-management execution layer available to Grok Bot.

Ryze implements approved paid instructions. It does not own paid strategy or approval. Treg and Search Console can validate Ryze data; they do not silently replace Ryze as the operational SEO monitor.

Treg: supplemental access, not silent replacement

Treg provides supplemental access to live data when direct connectors are missing or inconvenient. Every observation still needs the provider, account or property, metric definition, date range, timezone, and freshness.

If a connector is missing, it is better to mark the source unavailable than to invent continuity by quietly swapping definitions.

Ansible: CRM authority and approved publishing surfaces

Ansible remains authoritative for CRM records, qualification, sales progression, and business outcomes. It also provides operational publishing and delivery surfaces for approved authentic blog content and permission-based newsletters.

Drive may hold a reporting projection. Conflicts about CRM outcomes resolve in favor of Ansible. generate_lead is the canonical website conversion event for valid inquiries. Activity in ad platforms or analytics is not the same thing as a commercial outcome.

Cursor, GitLab, and GitHub: bounded implementation

Cursor implements approved changes in Ansible or endertech.com—landing pages, CRO tests, tracking, CMS capabilities, and related integration work. GitLab is the repository source of truth and the human review and merge surface. GitHub may be a synchronized analysis surface where available; it must not be treated as more current than GitLab.

Cursor work should produce a branch, tests, documentation, and a draft merge request. Human review and merge remain required. That is how website and tracking changes stay event-driven after approval rather than continuously self-editing.

Postiz and Social Bloom: publishing and cold outreach

Postiz owns social scheduling and analytics. Grok Bot uses platform analytics collection so unusually strong posts or time-sensitive comments can reach the next review while they are still actionable. ChatGPT determines editorial strategy and draft quality; Grok Bot schedules approved content.

Social Bloom owns cold prospect sourcing, sending, and nurture until a meeting is handed to sales. Jonathan, as sales owner, owns continued one-to-one nurturing from that point. The system judges replies, qualified conversations, meetings, opportunities, opt-outs, and CRM outcomes—not opens or send volume.

Cold outreach audiences stay separate from permission-based newsletter audiences. Consent rules are not a technical afterthought; they are part of the architecture.

Google Drive and the Growth Decision Ledger

Drive is the neutral coordination layer between otherwise disconnected systems. Grok Bot writes evidence packets, validation records, and handoffs into a dedicated evidence folder. ChatGPT strategy and governance artifacts stay in the parent AI-CMO folder.

The Growth Decision Ledger is the cross-platform decision and normalization surface. Grok Bot does not write the Sheet directly. It writes dated packets. ChatGPT or a designated human marks each packet processed and merges only decision-relevant material. That keeps history intact and prevents “the latest summary” from pretending to be the system of record.

Stable Decision IDs, related experiment IDs, approval status, and execution status make correlation possible. Recommendation is not approval. Approval is not execution. Execution is not verification.

MCP: from model reasoning to dependable action

MCP tooling matters because it turns model intelligence into bounded business operations. The useful pattern is not “give the model the whole company.” It is “expose precise tools with clear permissions, readable failure, and authoritative read-back.”

When a needed interface is missing, the correct response is often to build the interface—not to invent a workaround that quietly changes the meaning of the data.

Human owners complete the architecture

Human-in-the-loop is not a disclaimer attached to automation. It is part of the state machine.

Budget changes, public positioning, production code, publishing, outreach strategy changes, and other consequential actions require explicit recorded approval unless a narrower standing authority has already been granted. Named owners exist for strategy approval, marketing supervision, sales progression, delivery feasibility, and technical credibility.

Without that, the rest of the diagram is only software connected to other software.

Three flows that make the ownership real

Paid change. Evidence arrives. ChatGPT recommends a Change or Test. A human approves. Grok Bot turns the approval into bounded instructions. Ryze executes in the ad platform. Grok Bot reads the platform state back. ChatGPT reconciles the ledger only after verification matches the approval.

Website or CRO change. Evidence and strategy produce a decision. After approval, Grok Bot hands a bounded packet to Cursor. Cursor opens a branch, adds tests, and prepares a merge request. Humans review and merge. Verification confirms the live behavior, not only the pull request title.

Authentic blog draft. ChatGPT owns strategy and standards. Grok Bot discovers sources, checks duplication and confidentiality, and creates an unpublished Ansible draft. Publication remains a separate human approval. Draft creation is not publication authority.

Those flows share one design idea: systems receive only the context and authority they need. Specialist platforms should not receive unrelated private strategy just because an agent can copy it.

What another company can borrow

You do not need our exact stack to use the pattern.

Centralize strategy. Distribute execution. Name one authoritative source per fact. Separate recommendation, approval, execution, and verification. Give recurring collection its own operator. Keep humans in the consequential path. Build missing interfaces instead of permanently working around them.

Source-of-truth rules that prevent polite confusion

Most multi-tool stacks fail in the same quiet way: every system can speak, so every system starts sounding authoritative. Our rule is narrower.

Ansible owns CRM outcomes and approved CMS or newsletter delivery state. GitLab owns code history and merge reality. Ryze owns its operational SEO and placement records and executes approved ad changes. Postiz owns social scheduling and platform analytics state. Social Bloom owns cold-outreach activity through meeting handoff. Drive transports evidence. The Growth Decision Ledger normalizes decisions. ChatGPT interprets. Grok Bot coordinates. Humans authorize consequential action.

When systems disagree, we keep both observations long enough to compare definitions and date ranges, then identify the authoritative source. We do not average them into a comforting compromise.

That discipline is also why Drive packets always need source, period, timezone, freshness, and limitations. A number without provenance is not evidence. It is decoration.

What “job descriptions for AIs” change in practice

Writing roles down changed day-to-day behavior more than any connector did.

Strategy reviews stopped trying to collect everything. Collection jobs stopped pretending to set portfolio policy. SEO monitoring stopped being asked to invent paid strategy. Cold outreach stopped being judged by vanity send metrics. Blog production stopped treating draft creation as publication. Website work stopped arriving as vague wishes and started arriving as acceptance criteria.

The architecture is still imperfect. Interfaces fail. Evidence is sometimes stale or incomplete. Standing authority has to be recorded carefully or people invent it under deadline pressure. But the job-description model gives the organization a way to notice those failures as design problems rather than personality problems.

Authority boundaries in one sentence each

Useful architectures can be summarized without losing the hard edges.

• ChatGPT may recommend portfolio and channel strategy; it may not silently spend, publish, or ship production code.

• Grok Bot may collect, prepare, draft, and orchestrate approved work; it may not invent approval.

• Ryze may execute approved SEO operations and approved ad changes; it may not own paid strategy.

• Treg may validate or supplement live access; it may not redefine the metric.

• Ansible may record commercial truth and host approved delivery surfaces; a Drive summary may not outrank it.

• Cursor may implement approved code and site changes through review; it may not merge itself into production authority.

• Postiz may schedule approved social work and expose analytics; it may not set editorial strategy.

• Social Bloom may run cold outreach through meeting handoff; sales owns what follows, and newsletter consent stays separate.

Those sentences are intentionally short. Ambiguity is where unsupervised systems grow.

If Part 1 was the discovery that specialization beats the monolith, Part 2 is the organizational chart that makes specialization safe enough to use.

The next article covers the learning loop itself: daily and weekly cadence, decision vocabulary, read-back verification, failure preservation, and how procedures change when evidence exposes a flaw.

One more practical test: if a new tool cannot be given a job description that fits these rules, it does not belong in the operating system yet. It may still be useful as an experiment. It should not receive production authority by accident.

Borrowed correctly, the pattern reduces tool sprawl by making ownership expensive to ignore and cheap to inspect.

That inspection habit is the real product of the architecture, more than any single platform choice.