Service as Software hasn't reached marketing yet. Here's the codification gap that's blocking it.

Open Cursor — the editor, not the marketing site. Pull up any open-source repository with more than fifty contributors. Start a session. The agent reads the README, the CONTRIBUTING.md, the linter configuration, the test suite, the closed pull requests with reviewer comments, the issue threads where someone tried the obvious solution and watched it fail. Before you type a single prompt, the agent has read the messy middle of the project — every dead end, every reviewer pushback, every reason a clean-looking refactor got rejected three months ago. Now open your marketing function. Open the brand voice doc. Open the campaign post-mortems. Open the Slack thread where last quarter's brief got rewritten twelve times before launch. Open the abandoned campaign from Q2 that nobody talks about. There is no equivalent. The messy middle of marketing isn't on the page. It's in DMs, Looms, and people's heads.

In March 2026, Julien Bek at Sequoia published Services: The New Software and named a category that had been forming for two years. Companies like Crosby (legal NDAs), Pace (insurance claims handling), Anterior (healthcare medical coding), and WithCoverage (insurance brokerage) had stopped selling AI tools and started selling the work itself. The buyer no longer pays for software access; the buyer pays for the closed ticket, the drafted contract, the resolved claim. Bek's framing has been adopted across verticals — by security operations companies, by maritime platforms, by global consultancies — and the term is becoming category vocabulary. Marketing has not caught up. This piece argues that the gap isn't strategic, it's structural. Marketing hasn't become Service as Software because the work product was never written down in a way an autonomous system can pick up. Coding got there first because the repository had been the source of truth by convention for decades. Marketing has no equivalent convention. The fix is the convention — built deliberately, per client, codified at the artifact level. We call our version Codified Engagement. The case for it follows.

Every "AI marketing platform" pitch in 2026 — the chat assistants, the agentic creative tools, the GEO/AEO SaaS layer — smuggles the same assumption: that the gap between marketing-as-it-is and marketing-as-Service-as-Software is a model problem to be closed with better prompts, better retrieval, or better fine-tunes. The actual gap is that the buyer's own marketing function never wrote down what it was doing in the first place, and no model fixes that.

What Service as Software actually means

Bek defines Service as Software with one clean test. If you sell the tool, you're in a race against the model. If you sell the work, every improvement in the model makes your service faster, cheaper, and harder to compete with. A company might spend $10K a year for QuickBooks and $120K on an accountant to close the books. The next legendary company will just close the books. The work budget — six dollars for every one dollar spent on software — is the addressable market. Tools are the wedge. Outcomes are the sale.

The distinction matters because the term has been picked up across verticals. The security operations company 7AI uses "Service as Software" as branded positioning — AI agents that operate end-to-end inside a SOC, delivering enriched alerts and closed investigations rather than dashboards. That's the autopilot framing applied to security. The Thoughtworks analyst piece (December 2025) covers the agentic-systems substrate well — reasoning engines, memory, tool orchestration, the new feedback-loop discipline — but it doesn't anchor the commercial logic. The shift from copilot to autopilot is the economic engine. The agent architecture is the substrate that makes it possible. Different layers of the same stack.

When we use "Service as Software" in this piece, we mean the strict version: the seller captures the work budget by delivering the outcome end-to-end, not the tool budget by enabling a human to deliver it faster. The chat-window products are copilots. The autopilots — Crosby, Pace, Anterior, WithCoverage, 7AI — are something else.

Why coding agents got there first (the legibility precondition)

Bek's piece explains why Service as Software wins. It doesn't fully explain why some categories got there first. The complementary argument — call it the legibility precondition — is what coding-agent products have been quietly demonstrating since Cursor and Windsurf went mainstream.

Software engineering, as a profession, codified its work product over four decades. The repository is the source of truth by industry convention. Pull requests carry the reviewer's reasoning. CONTRIBUTING.md spells out the rules of the road. Linters enforce style. Test suites encode the spec. Closed issues record the dead ends. None of this was built for AI agents; it was built for humans onboarding into codebases. The agents inherited it for free.

Marcel Santilli, who has been making the case in interviews and podcast appearances, frames it the same way: coding agents work because every repository's messy middle is in the open by convention. Pull requests, comments, doc strings, dead-end branches. There's a public record of why the code looks the way it does, not just what the code is. The "why" is the part agents need.

Andrej Karpathy's Software 3.0 framing at Sequoia Ascent in 2026 names the same precondition without using the word. The agent operates on sensors (queryable inputs) and actuators (callable outputs), with prompts as the new code and a context window holding the working set. The repository, in his framing, is the agent's primary sensor surface. When the sensor surface is rich — decades of structured artifacts — the agent's judgment quality climbs. When it's thin — a Notion doc and a Slack history — the agent flails.

Anthropic's Building Effective Agents documents the same observation from the platform-vendor side. The workflow patterns the paper catalogs — prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer — all depend on legible inputs at every step. The agent doesn't infer from absence. It operates on what's queryable. If the input layer is sparse, no architecture trick recovers it.

The conclusion shows up across all of these sources: coding became Service-as-Software-capable because the work product was already legible. The autopilot startups Bek names sit in categories with the same precondition — structured documents, schema-driven inputs, standardized outputs, regulated forms. Legibility was the precondition. AI was the unlock.

Why marketing isn't there yet (the legibility gap)

Marketing has none of this.

Brand voice documents exist, but they're aspirational. They describe how the brand should sound, not how decisions actually get made. The real brand voice — the one a campaign post-mortem reflects — lives in the lifecycle lead's Slack history, the founder's edits to Q3 launch copy, the agency-of-record's quarterly slide that nobody outside the room sees. An agent reading the brand voice doc gets the marketing equivalent of a corporate mission statement: technically true, operationally useless.

Campaign post-mortems, when they exist, are slides. The actual learnings live in the meeting where the post-mortem was discussed and the three side conversations afterward. The decision to kill last quarter's loyalty program lives in a DM thread between the head of growth and the founder. The reason the email frequency cap got loosened in February is captured nowhere except in the lifecycle manager's memory.

Even the data layer — the marketing platforms that should be queryable — is queryable only at the surface. An agent can pull open rate by segment for the last ninety days. It cannot pull the reasoning behind why segment B's frequency cap was set to four per week and segment C's to two, or why the abandoned-cart sequence was rebuilt in March and quietly rolled back in April. The what lives in the data. The why lives in nobody's file.

And the SaaS layer that claims to make marketing "agent-ready" is optimizing for the wrong layer entirely. Pedro Dias's The Whole Point Was the Mess (May 2026) dismantled the GEO and AEO SaaS category by pointing out that the academic paper their product strategies borrow from — Aggarwal et al., KDD 2024 — never tested the schema and structure interventions those tools sell. The schema layer is downstream of the codification layer. Selling it as the precondition is selling a brochure as the engine.

This is the failure mode every operator has watched first-hand. Bring in a marketing AI tool. Run a campaign through it. Look at the output. The copy is technically grammatical and roughly on-brand. It's also generic. It doesn't reference the conversation last month about positioning the loyalty program against the category leader. It doesn't know the founder's pet objection to that one phrase. It doesn't carry forward the small operator decisions that, in aggregate, were the brand voice. The output is a faster typewriter — faster than a junior copywriter, but still a typewriter. The work didn't compound, because nothing about the previous engagement was captured in a way the next invocation could read.

This is the copilot pattern, played out inside marketing. The marketing AI tools in market in 2026 are copilots wearing autopilot clothes. The operator types into the window. The system generates. The operator edits. The operator ships. The operator is still the unit of work.

What unblocks it (codification at the artifact level)

The fix is the convention coding had by accident, built deliberately for marketing, per client. Our version of it is Codified Engagement. The deliverable that runs the engagement isn't the team or the deck — it's a per-client file with five components.

The first component is the working hypothesis. Three sentences at the top, updated weekly by the operator. What the brand is trying to do. Why now. What's blocking it. The hypothesis isn't a strategy doc; it's a queryable artifact the agent reads first on every task. When the hypothesis changes, every downstream skill changes with it.

The second is the locked rules. Brand voice constraints. Regulatory limits. Off-limit topics. Recent founder calls that override defaults. These are the constants the agent reads on every invocation. They're written for an agent to enforce, not for a slide to look good.

The third is the skill index. Small markdown files — one per recurring marketing task — that the agent can pull in by name when a task matches. Each skill has a clear trigger condition and a clear scope. Skills compound. A new engagement adds a handful of new ones, the agency grows the index, and the next client benefits from the discipline of the previous one without inheriting the previous brand's specifics.

The fourth is the memory index. Pointers to memory files that capture what the operator learned that isn't derivable from the brand's data or the brand's positioning — the off-screen decisions, the failed experiments, the recurring objections, the people behind the people. The memory layer is what most marketing AI deployments are missing entirely. Without it, every conversation with the agent starts from zero.

The fifth is the kill switch. Hard limits on what the agent can do without human approval: no external publishing, no sends above a defined recipient count, no paid-media spend above a stated threshold, no overrides of the locked rules. The agent stops and escalates when the gate triggers. Silent failure is the dominant risk mode in AI-native delivery; the kill switch is the only structural protection against it.

This file is the artifact. It's versioned. It's editable by the operator and readable by the agent. Every client conversation either updates the file or doesn't count. The Friday review pass, the Tuesday brief, the Wednesday CRO sprint — all operate against the same file. If a decision happens off-file, the file is wrong and gets fixed before the next invocation.

The shape replicates. The install does not. Knowing which skills matter for this brand, in this category, at this stage of customer adoption is the week-one operator work.

Where the pattern breaks (the honest counterarguments)

We've heard four counterarguments in client conversations. They're worth answering directly.

"Marketing has data — isn't that the equivalent of a repo?" No. Marketing data is what happened. The repo equivalent is what was thought — the decisions, the dead ends, the rejected creative directions, the pricing iteration, the brand-voice debates. Data is downstream of judgment. Judgment is what doesn't get captured. An agent that reads the data without the judgment will optimize the wrong loss function, beautifully.

"Brand voice documents already exist." They do. They're not operational artifacts. An aspirational brand voice doc lives on a wiki — read at onboarding, forgotten by month three. An agent-readable per-client file is loaded by the agent on every task, every campaign, every draft. The first is what you'd like to be true. The second is what actually shapes the output.

"This is consulting with extra steps." Fair pushback. The test is straightforward. Is the artifact maintained, versioned, and queryable by the agent at handoff — or is it a one-time deck? If it's a deck, it's consulting. If it's a runtime configuration the agent reads on every invocation, it's a moat. The artifact the agent operates against on Tuesday at 9 AM, after the Monday client call has updated three lines in it, is something a deck has never been.

"Bek's opportunity map doesn't list marketing." Correct, and the omission is the bet. The map covers nine verticals — insurance brokerage, accounting and audit, healthcare revenue cycle, claims adjusting, tax advisory, transactional legal work, IT managed services, supply chain and procurement, recruitment — plus a tenth, management consulting, flagged as judgment-heavy. Marketing isn't on the list. Three frictions explain why. The work product is less legible than legal contracts or medical codes. The outsourcing layer (the agency stack) is more fragmented than insurance brokerage. The buyer-seller relationship runs hotter than healthcare revenue cycle. Those three frictions are also what create the pure-play opening. The firm that solves the codification problem first doesn't just capture the work; it captures the entire downstream automation stack the easier categories are converging on.

The convergence is the story

Six verticals. One frame.

Legal: Crosby for NDAs, Harvey for the broader copilot-to-autopilot transition, Lawhive for autopilot-native consumer legal. Insurance: WithCoverage for brokerage, Pace for claims, Strala for AI-native TPA, Harper for newer commercial lines. Healthcare: Anterior for revenue cycle. Tax: TaxGPT, Skalar, Ravical. IT managed services: Edra and Serval. Procurement: Magentic, AskLio, Tacto. Recruitment: Juicebox, Mercor, Jack & Jill. Security operations: 7AI. The list isn't exhaustive; it's representative. Each company sells outcomes, not tools. Each captures the work budget, not the tool budget. Each operates inside a category where the work product was already legible — by professional convention, by regulatory schema, by industry standardization — before the AI arrived.

Marketing is the next category. The firm that gets there first will be the one that solves the legibility problem at the per-client artifact level. The tool layer — the marketing AI SaaS, the agentic creative platforms, the GEO/AEO category — will not solve it, because the gap is upstream of the tooling. The gap is in what nobody wrote down.

Bek's closing line in Services: The New Software names the moment we're in. "In 2025, the fastest-growing AI companies were copilots. In 2026, many will try to become autopilots. They have the product and the customer knowledge. But they also face the innovator's dilemma: selling the work means cutting their own customers out of doing it. That's the opening for pure-play autopilots."

For marketing, the pure-play opening goes to the firm that starts from the codification layer and treats AI as orchestration over a legible work product, instead of the firm that starts from a chat window and tries to retrofit codification afterward. The pivot is uphill from the chat window. The build is downhill from the codified file.

If your marketing AI rollout still feels like working for a chat window, the gap isn't your model. It's that nobody has written down what your marketing function actually does — at engineering grade, in a file the agent reads first on every invocation. The codification is the precondition. The autopilot is downstream.

Book a strategy call →