Run Your Customer Platform from Claude Code — and Slack
By SocialHub.AI Team
The unlock isn't a faster dashboard. It's a different operating model: a governed agent inside the AI tools your team already uses — answering and acting in plain language, without exporting data or giving up control.
The bottleneck was never the dashboard
Every retention team has the same midweek ritual. Someone asks a sharp question — "how did GMV move last week, and why are redemptions soft?" — and the answer takes a day. Not because the data is missing, but because getting to it means a dashboard that doesn't quite have the cut you want, a Slack ping to the analytics person, an export, a pivot, and a follow-up question that starts the cycle over. The signal is there. The path to acting on it is the problem.
We've spent the last few years arguing that retention is a loop — Capture, Decide, Activate, Accumulate — and that the missing node for most brands is Decide: the agentic layer that reads the profile and chooses what to do next. SoCode is what Decide looks like when you put it in the hands of a person, in the tool they already have open. It is SocialHub's integration for Claude Code (and Claude Desktop and Cursor): a downloadable skill, flash-operations, plus a governed MCP server. You operate the platform and query governed metrics in plain language without leaving your editor. It's available now.
The point isn't a slicker chart. It's a different operating model. The answer and the action move to where the work already happens, self-serve, with governance baked in — no data export, no loss of control.
Scenario 1 — The growth lead who needs the answer before the standup
Before: your growth or analytics lead wants "GMV last week by store, and why are redemptions down?" That's two questions and at least one judgment call. Today it means a dashboard for the first half, a manual dig for the second, and — if the dig gets interesting — a ticket to someone who can write SQL. The honest answer lands after the meeting where it would have mattered.
After: they type it into Claude Code. The flash-operations skill recognizes a Flash question, calls the MCP server, and the GMV figures come straight from the certified semantic layer — the same definition of GMV your dashboards use, not a number the model improvised. Then the agent does the part a static dashboard can't: it follows the thread. It pulls redemption trend, segments it, and surfaces the likely driver — a coupon pool that ran dry, a tier whose activity slipped — and shows its work as it goes.
Example asks that just work: "GMV last week by store." "Why are redemptions down versus the prior week?" "Show me redemption rate by coupon pool for the last 14 days." The lead walks into standup with a governed answer and a hypothesis, not a promise to circle back.
Scenario 2 — The marketing manager who can't write SQL and shouldn't have to
Before: a marketing manager suspects engagement is slipping. "Did active members drop versus last month, and is it concentrated in a tier?" is a perfectly reasonable thing to want to know. It's also a multi-step diagnosis — compute active members for two windows, break by tier, compare — that they cannot self-serve. So it becomes a request, the request becomes a queue, and by the time the analysis comes back the moment to act on it has passed.
After: they ask the agent directly. "Did active members drop versus last month, by tier?" The metric comes from the certified layer with a consistent definition of "active," the comparison runs across both windows, and the breakdown comes back in seconds — Gold steady, Silver soft, new members fine. A natural follow-up — "which stores drove the Silver drop?" — chains right off the first, because the agent holds the thread instead of resetting it.
This is the quiet shift. The diagnosis happens while it still matters, run by the person who owns the outcome, without a handoff. The analyst's queue gets shorter, and the manager stops waiting on a number to decide whether there's even a problem worth chasing.
Scenario 3 — The engineer for whom integration becomes a config line
Before: an AI or ML engineer wants their own assistant or Cursor to reason over governed business metrics. Historically that's a project — request access, stand up a pipeline, replicate metric logic somewhere new, and then own the drift forever as definitions and permissions diverge from the source of truth.
After: they point their MCP-capable client at the same governed SocialHub MCP server. The integration that used to be a quarter of roadmap becomes a configuration line. Their assistant can now ask for GMV, active members, or redemption rate and get the certified definition — the one finance and marketing already agree on — instead of a hand-rolled copy that silently goes stale.
And because it's MCP, the same surface that serves a human in Claude Code serves a machine in Cursor. One governed contract, two consumers. The engineer ships against business-grade metrics without becoming the permanent owner of a metrics replica.
Governance is the product, not the disclaimer
Self-serve AI over your customer platform is only worth having if you can trust it and contain it. SoCode is built so the answers are real and the actions are bounded. Every metric number comes from the certified semantic layer — the AI does not invent figures. When it can't ground a number, it says so rather than guessing, which is the difference between a tool you brief executives from and a toy you double-check.
Actions are governed the same way. Reading is open under a metrics:read preset; anything that writes requires an explicit write scope and passes a server-side guard that the client cannot talk its way around. Every key is tenant-scoped, so an agent only ever sees one tenant's data. Every call is audited. Writes are confirmed, not fired blind — and the audit log means you can always answer "who changed what, and when."
The adoption path follows the trust. Start read-only with the metrics:read preset, let the team get answers, and add write scopes only for the specific operations you want to enable. You expand capability deliberately, on your terms, instead of handing an agent the keys on day one.
From answers to actions — inside the loop
Querying is where most teams start, but the same governed surface runs approved operations: manage loyalty members and tiers, award or redeem points, work with coupons and coupon pools, issue ambassador codes. That's what turns SoCode from a reporting convenience into an operating model. "Active members dropped in Silver" stops being a finding you route to someone else and becomes a thing you can act on — diagnose, then execute, then watch the next read tell you whether it worked.
That is the retention loop, compressed into one conversation: analyze, execute, improve, continuously. The agent reads governed metrics (Decide), runs an approved, audited action (Activate), and the next query reflects the result (Accumulate, then Capture again). The loop that we usually draw as four boxes on a slide becomes a back-and-forth in your editor — with a write scope and an audit trail keeping it honest.
We've seen what closing the loop is worth at scale. McDonald's China grew the member share of GMV from 5% to 85% by treating retention as a system rather than a series of campaigns. The mechanics here are the same idea, brought down to the altitude of a single ask: make the next best action easy to find and safe to take.
SoTag — the same agent where teams already coordinate (in progress)
Claude Code is home for analysts and engineers. It is not where a marketing manager, a merchandiser, or a regional lead spends their day. Those teams coordinate in Slack — and that's where SoTag comes in. SoTag is the same governed agent, in progress and coming, available in the channel where decisions actually get made.
Picture it. In the #retention channel someone types, "@SocialHub active members by tier vs last month" and the governed answer posts inline, certified figures and all, visible to everyone in the thread. Or, with the right scope, "@SocialHub top up the summer coupon pool by 500 codes" — confirmed, executed, and audited, in front of the team, with the same server-side guard and tenant scoping as the editor. SoTag is explicitly in progress; we're calling that out so you can plan around it rather than wait on it.
The reason it matters is reach. A governed agent in the editor unlocks the technical bench. The same agent in Slack unlocks everyone else — the people who own the campaigns, the stores, and the calendar — without asking them to learn a new tool or file a request. The loop runs faster when the whole team can take a turn.
Start read-only, then widen the door
The case for SoCode is not that dashboards are bad. It's that the operating model around them is slow, and the fix is to move governed answers and actions into the AI tools your team already uses — without exporting data and without giving up control. Certified metrics keep the answers trustworthy; scopes, server-side guards, tenant isolation, and audit logs keep the actions safe.
The low-risk way in is exactly how it's designed to be adopted: install the flash-operations skill, connect the governed MCP server with a metrics:read preset, and let your team ask real questions for a week. Add write scopes only when you've decided which operations are worth enabling. You can read more on /resources/socode and see where this fits in the bigger picture on /platform/ai-frontier.
If you want to see your own GMV, active members, and redemptions answered in plain language — and a roadmap to SoTag in Slack — book a demo. Or skip the meeting and start with SoCode: read-only, governed, in the editor you already have open.