Meet devGary: The CMS Editor That Lives in Linear
How we built a multi-agent content pipeline in Claude Code that takes tickets, ships changes through your existing CMS and Git workflow, and refuses to break the homepage.
It's 5:47 on a Tuesday. The campaign goes live at 6:00.
A marketing manager needs three image swaps and a copy change on the homepage. The dev team is heads-down on a release. The CMS has a learning curve she doesn't have time for tonight. The campaign launch isn't waiting.
She opens Linear, writes a one-paragraph description of what needs to change, and tags the issue
@devGary.
Three minutes later, the changes are live. The Linear issue updates itself with a summary of what Gary did, links to the updated pages, and a note: "Did not action the request to delete the 'Solutions' nav item — flagging for human review as it appears destructive."
devGary is a multi-agent AI pipeline. We built him.
What devGary Is
devGary isn't one agent — he's two, working in sequence.
A triage agent reads every ticket tagged @devGary (and every subsequent comment on it). It decides three things: Is this actionable? Is it a content edit or a code change? Does the ticket contain enough information, or does Gary need to ask a clarifying question first?
An execution agent then does the work, in one of two lanes:
- Content lane — talks to Umbraco through an MCP server. Updates document properties, swaps block content, publishes pages.
- Code lane — opens a Pull Request against the
dev branch on GitHub. Humans review and merge.
When the work is done — or refused — Gary writes back to the Linear ticket. That comment is the audit trail.
The plumbing is intentionally boring. The point isn't the architecture, it's that Gary is bounded, traceable, and promotable.
- Bounded — he edits content directly; he proposes code via PR. He can't deploy, can't run SQL, can't change permissions.
- Traceable — every change is a ticket. Every ticket has a Gary-authored comment with a summary. Every PR has a clean diff. The audit trail is free.
- Promotable — he doesn't bypass the editor workflow or the SDLC. Content goes through the same publish flow as a human editor's. Code goes through the same review-and-merge flow as a human developer's.
Comments Are the Control Surface
The most important design decision in devGary isn't visible in any diagram. It's that humans steer Gary by replying on the ticket — no separate UI, no admin dashboard, no Slackbot.
If you want to clarify a request, you comment on the ticket. If you want Gary to retry with new context, you comment on the ticket. If you want him to stop, you comment on the ticket. He sees the full thread, including everything humans have said since he last looked, and responds accordingly.
This sounds small. It isn't. The single biggest reason AI automation projects stall is that they require teams to adopt a new interface. devGary lives inside an interface your team already uses fluently. The cognitive load of working with him is zero.
The MCP Pivot
We started building Gary's Umbraco integration the old way: a custom backoffice controller in Umbraco 13, hand-rolled endpoints, bespoke auth, lots of glue.
On April 27 we threw it away.
Umbraco shipped a native MCP server with v17. We rebuilt Gary as a standard MCP client — same model, same prompt, same triage logic, but pointed at the platform-provided server instead of our custom one. The result was less glue, less maintenance, less drift between our agent's tool surface and what the CMS actually exposes.
The lesson is generalizable: when the platform you depend on ships an MCP server, use it. The maintenance burden of a hand-rolled integration grows linearly with the platform's API surface. The maintenance burden of an MCP client is constant. We expect to make this trade in every CMS, CRM, and ticketing platform Scylla works with as they ship their own MCP servers over the next 12 months.
The Guardrail Question
Every CIO conversation about content agents stalls at the same place: "Cool. What stops it from torching the site?"
Three things stop devGary:
- The MCP boundary. The Umbraco server exposes hundreds of verbs. Gary is allowed only a tight allowlist of writes —
update-document-properties, update-block-property, publish-document, and a handful of read verbs for context. He literally cannot delete a top-level page through the channel we gave him. The most destructive verb in his vocabulary is "unpublish" — which is reversible.
- Triage-before-action. Nothing happens until the triage agent has classified the ticket. Ambiguous tickets get a clarifying comment, not a guess. Destructive intent gets flagged, not actioned.
- The comment thread. Every action is announced. Every refusal is logged. Humans can intervene at any point by replying on the ticket.
This is the part that turns an interesting demo into something a regulated industry will actually deploy. The technology has been ready for a year. The integration pattern is what's been missing.
Why Content Management Is the Right Place to Start
Most AI-automation pitches lead with the marquee use case: an agent that does the hard creative or strategic work. Those agents are exciting and most of them aren't ready.
Content management is the opposite. It's high-volume, low-judgment, high-friction work that already eats developer time at every agency and in-house team we know. The tasks are well-typed. The rollback story is excellent. And the ROI is countable in tickets-per-week.
If you're a CMO, devGary is the difference between your campaign timing being limited by IT capacity versus by your strategy.
If you're a CIO, he's the lowest-risk place to run your first agentic-workflow pilot — because everything he does is observable, reversible, and routed through your existing tooling.
What's Next
devGary started narrow — media swaps and small copy edits — and is widening to general content edits across the site. The next milestones:
- Repo-aware code lane so multi-repo clients get the right PR on the right branch automatically.
- Headless CMS support (Contentful, Sanity, Strapi) as those platforms ship MCP servers — the integration becomes a configuration change, not a rebuild.
- Cross-system workflows — a ticket that says "launch this product on the website and in HubSpot," with Gary coordinating both.
We didn't build Gary as a demo. We built him because the content-management bottleneck is the most expensive bottleneck in modern marketing operations, and nobody had a good answer that wasn't "hire a junior content producer or train your marketers on the CMS."
Want a Gary for Your Stack?
We build agents like Gary as a managed service — the triage logic, the MCP integration, the allowlist, the comment-thread protocol, and the ongoing tuning as your content model evolves. The pilot is bounded: your CMS, your ticket queue, your guardrail policy, a defined scope of ticket types, and a clear handoff to your team.
