---
sharksapi_version: p-9f8f2d36f0
name: marketing-context
description: Build and maintain the shared marketing context ("brand brain") every marketing agent on the project consumes — product, ICP, positioning, competitors, voice, constraints, goals. Auto-drafts from the project website, connected data and existing memory; asks only for what is genuinely missing; stores confirmed facts in shared memory so channel agents never re-discover them.
allowed-tools: [memory_bootstrap, memory_search, memory_write, memory_update, get_team_capabilities, list_connections, get_connection_status, scrape_website, analyze_competitor_website, get_gsc_brand_queries, get_gsc_top_queries, get_ga4, read_dashboard, get_team_skill, list_wp_posts, search_drive, get_drive_file_content, notion_search, submit_draft]
metadata:
  role: manager / orchestrator (channel agents consume the output, only the orchestrator maintains it)
  triggers: [marketing context, brand brain, brand context, set up marketing context, who is our customer, our positioning, icp, brand voice, update marketing context, turunduskontekst]
  sources: "Adapted for SharksAPI from coreyhaines31/marketingskills (MIT, © 2025 Corey Haines) and alirezarezvani/claude-skills marketing-context patterns (MIT, © 2025 Alireza Rezvani). Synthesis, not verbatim copy."
---

# Marketing Context (Brand Brain)

Create and maintain the shared foundational marketing context used by every marketing agent on this project. One well-maintained context package replaces the repeated discovery every channel agent would otherwise do — and keeps positioning, voice and constraints consistent across SEO, social, paid, email and content work.

**This skill has two modes:**
- **Create** — no context exists yet: draft it from live data, confirm gaps with the human, store it.
- **Update** — context exists: review, amend what changed, never silently overwrite.

All JSON snippets are `params` payloads for `POST https://sharksapi.ai/api/v1/a2a` (`Authorization: Bearer {token}`). Before calling any tool, fetch the live schema — `GET /api/v1/a2a/tools` — and use only tools that actually appear there.

## What the context captures

| Block | Contents |
|---|---|
| Product | Overview, category, business model, pricing |
| Market | Target market, ICP, buyer roles/stakeholders, anti-personas |
| Demand | Jobs to Be Done, pain points, trigger events, desired outcomes |
| Competition | Direct / secondary / indirect competitors, positioning, differentiators, proof points |
| Objections | Common objections + answers, alternatives buyers consider |
| Voice | Brand voice, tone by channel, preferred and forbidden words, CTA preferences |
| Constraints | Compliance rules, brand constraints, budget/autonomy constraints (read-only for channel agents) |
| Assets | Existing assets and connected data sources |
| Goals | Marketing goals and KPIs (anonymous — never applicant/customer PII) |

## Phase 0: Preconditions

1. `{"tool": "memory_bootstrap", "arguments": {}}` — ALWAYS first. If the bootstrap already contains `fact` entries titled `context:*`, you are in **Update mode** (Phase 4).
2. `{"tool": "memory_search", "arguments": {"query": "context", "scope": "global"}}` — catch entries the bootstrap budget cut off.
3. `{"tool": "get_team_capabilities", "arguments": {}}` — which roles exist, which data sources are LIVE vs missing.
4. `{"tool": "list_connections", "arguments": {}}` — what you can auto-draft from.

Only the orchestrator/manager (or a human) may write `global` scope and `constraint` entries. If you are a channel agent and the context is missing, do NOT build it yourself — record a `task_state` entry asking the orchestrator to run this skill, and proceed with explicit assumptions labelled as assumptions.

## Phase 1: Auto-draft from live data (before asking anything)

Collect what already exists — ask the human only for what you cannot find:

1. **Website**: `scrape_website` on the project's homepage, pricing page, about page → product overview, category, pricing model, stated positioning, CTAs, tone.
2. **Search reality**: `get_gsc_brand_queries` + `get_gsc_top_queries` → what the market actually types to find this project (brand vs non-brand demand).
3. **Traffic shape**: `get_ga4` (aggregate) → rough channel mix and scale, so goals are grounded.
4. **Competitors**: `analyze_competitor_website` on any competitor the human or memory names.
5. **Documents** (if connected): `search_drive` / `notion_search` for "positioning", "ICP", "brand", "messaging" → `get_drive_file_content` for hits.
6. **Existing dashboards**: `read_dashboard` on the manager dashboard (if `get_team_capabilities` says one exists) → current plan, KPIs, pillars.
7. **Existing content**: `list_wp_posts` (if WordPress connected) → what topics and voice are already published.

If a source is not connected, skip it and note the gap in the draft — never invent what a missing source would have said.

## Phase 2: Separate confirmed facts from assumptions

Structure the draft in two explicitly labelled halves:

- **Confirmed** — stated on the website, in documents, in existing memory, or by the human.
- **Assumed** — your inference from data (e.g. "ICP appears to be small-agency owners — top queries are agency-tool comparisons"). Every assumption names its evidence.

Then ask the human ONLY about: (a) blocks with no data at all, (b) assumptions that materially change strategy (ICP, positioning, forbidden claims, compliance constraints). Batch the questions — one concise list, not an interview. If no human is in the loop this session, submit the draft for review instead: `submit_draft` with `type` from the live enum (use a text/web type), `channel: "web"`, title "Marketing context — needs confirmation", and stop before Phase 3 writes.

## Phase 3: Store the context (Create mode)

Write each block as its own `global` memory entry so channel agents can consume selectively and updates stay granular. Prefix titles with `context:`:

```json
{"tool": "memory_write", "arguments": {
  "scope": "global", "type": "fact", "pinned": true,
  "title": "context:icp",
  "content": "2026-07-10 CONFIRMED: ICP = {who}. Buyer roles: {roles}. Anti-personas: {who not}. Evidence: {source}."
}}
```

Rules:
- One entry per block (`context:product`, `context:icp`, `context:jtbd`, `context:competitors`, `context:positioning`, `context:objections`, `context:voice`, `context:goals`). Pin them.
- Compliance/brand bans and budget rules go in as `type: constraint` (orchestrator/human only), e.g. `context:constraints` — "never claim X; forbidden words: …; tone on LinkedIn: …".
- Mark each line CONFIRMED or ASSUMED inside the content. Max ~1000 chars per entry — link out, don't essay.
- Never store applicant/customer personal data. Aggregate and anonymize.
- **Never overwrite silently**: in Create mode, if `memory_search` found an existing `context:*` entry you didn't expect, switch to Update mode for that block.

Finish by writing a `decision` entry summarizing what was created and what remains ASSUMED, and (if a manager dashboard exists) adding the open questions to it via a strategy card or `submit_draft` so the human sees them.

## Phase 4: Update mode

1. `memory_search` for `context:` → fetch all current blocks.
2. Diff against reality: re-run the Phase 1 sources that are cheap (website scrape, brand queries) plus whatever prompted the update (e.g. voice-of-customer findings, a pivot).
3. For each changed block use `memory_update` (amend) or `memory_write` with `supersedes_id` (replace) — the old entry is archived, not lost.
4. **Positioning, ICP and constraint changes always need human confirmation** before superseding — submit the proposed change as a draft (`submit_draft`) or surface it as a dashboard action item; only apply after approval. Wording refreshes and new proof points may be applied directly, logged as `decision` entries.
5. Never delete a CONFIRMED fact because an analysis disagrees — record the contradiction as a `lesson` and escalate.

## Output: the context package

Alongside memory, produce a concise consumable package (markdown, ≤1 page) for whoever invoked the skill — the same structure as the table above, CONFIRMED/ASSUMED labelled, ending with "Open questions". Channel agents get this automatically via `memory_bootstrap`; the package is for humans and for attaching to delegated A2A task payloads.

## Verification

- `memory_bootstrap` again → confirm every `context:*` entry appears (pinned entries must survive the token budget; if cut, consolidate blocks).
- Confirm no PII and no invented facts: every CONFIRMED line has a source, every guess says ASSUMED.
- Only then mark any related strategy task complete (`update_strategy_task`) — creating a draft alone does not complete the task.

## Failure & fallback

- No website/scraper access → build from GSC/GA4 + human answers; record the gap.
- No memory tools in the live schema (older deployment) → deliver the package as a document/draft and tell the human where it lives; do not pretend it was stored.
- Human unavailable → store ASSUMED-labelled entries unpinned, create an action item for confirmation, and stop short of writing `constraint` entries.

## Relationship to other skills

- `voice-of-customer.skill.md` supplies evidence (quotes, pains, objections) — this skill decides what becomes canonical context, with human sign-off.
- Channel skills (`social-content-agent`, `paid-ads-operator`, `ad-creative-factory`, `campaign-analytics-agent`, `blog-writer`, SEO skills) consume `context:*` via `memory_bootstrap` and must not maintain their own competing copies.

## Sources & attribution

Workflow adapted from Corey Haines' *marketingskills* (positioning/foundation skills, MIT) and Alireza Rezvani's *claude-skills* marketing-context module (MIT), rebuilt on SharksAPI memory scopes, drafts and team tools. MIT license texts verified 2026-07-10.