Service-Dominant Logic & Value Co-Creation in the Age of AI

Goods-Dominant vs Service-Dominant Thinking

Service-dominant logic begins with a blunt correction. Service, singular, is the application of specialized competences for the benefit of another actor. Goods are only distribution mechanisms for service provision. That sounds academic until you look at how AI systems are currently sold. Most vendors promise faster answers, more summaries, more generated screens, more automated output. Those are goods-dominant promises. They assume value lives inside the object produced.

In practice, that assumption fails constantly. A generated journey map is worthless if the operations lead rejects its framing. An executive summary has no value if it cannot change a steering decision. A blueprint creates no value if it sits in a repo without changing the operating cadence, staffing logic, or service promise. The artifact is not the value. The artifact is a distribution mechanism through which value might later be co-created.

ASD aligns with SDL because it never treats an artifact as self-justifying. The system keeps dragging every claim back to its use context. Who is the beneficiary? What evidence shows the value proposition matters? What role does the human play in realizing it? What boundary conditions shape the outcome? When an architecture forces those questions, it becomes much harder to confuse production volume with service value.

This is why I resist describing ASD as a content generator for service design. It is a co-creation system. The role prompts, the skill library, the deterministic renderer, and the evidence loop are all there to improve the quality of actor-to-actor work between designers, stakeholders, frontline staff, and decision-makers. The artifact matters. The relationship between actors matters more.

That perspective also clarifies why the human phase gate is so important. If value is phenomenologically determined by the beneficiary, then the system must preserve explicit moments where institutional actors decide what they are willing to adopt, fund, or operationalize. A platform that tries to skip those moments may feel “more autonomous.” It is actually less service-aware.

Operant Resources: Agents Join the Workforce

SDL’s distinction between operand and operant resources is where agentic design starts to get interesting. Operand resources are acted upon. Operant resources do the acting. In a conventional software setup, data files, transcripts, dashboards, and PDFs are operand resources. Human expertise is the operant resource. In an agentic system, the picture changes: method manifests, role prompts, executable runtimes, and evidence structures all begin to act on the situation.

Agents are clearly operant resources. The Researcher can parse a large corpus. The Synthesizer can pattern-match across coded evidence. The Critic can challenge unsupported claims. The Measurer can structure a KPI tree. Each role applies competence rather than simply storing information. But the surprising shift in ASD is that evidence itself begins to behave like an operant resource once it becomes typed, queryable, and compulsory.

Raw notes in a folder are inert. Evidence rows in ASD are not. Because every row carries a kind, source, body, and content-addressed identity, the evidence register actively shapes what the rest of the system may claim. It constrains maps. It powers review. It blocks fabricated certainty. It redirects the work. In practice, that means evidence is no longer passive material waiting for a workshop. It becomes an active force in the service system.

{
  "evidence": {
    "id": "5ddb444f18bc3d27b30b5234346e90e05206c19af05c89506d7651625f2fd20f",
    "kind": "quote",
    "source": "maint-supervisor-04",
    "body": "If the tracker goes quiet for three days, the whole plant assumes the job is lost.",
    "capturedAt": "2026-08-23T09:14:00Z"
  }
}

Once that row exists, it can be cited by a journey map, pulled into a service blueprint, challenged by the Critic, linked into a KPI rationale, and surfaced in a report. That is evidence acting through the system. It is still human evidence. ASD does not magically convert people into data exhaust. But it does convert fragile research memory into a structured operant resource the practice can keep applying.

Method execution deepens this shift. The system does not ask an agent to “do some synthesis.” It returns an SOP with role-attributed steps. That means the method itself becomes an operant resource too: a callable, inspectable pattern of action that organizes how capability gets applied.

{
  "method": {
    "id": "kpi-tree-design",
    "phase": "measurement",
    "outputKind": "insight-set"
  },
  "steps": [
    {"role": "measurer", "instruction": "Name the north-star outcome in beneficiary terms."},
    {"role": "measurer", "instruction": "Decompose the outcome into driver branches and observable indicators."},
    {"role": "critic", "instruction": "Reject branches with no evidence, baseline, or owner.", "gate": true}
  ],
  "acceptance": [
    {"rule": "min-nodes", "min": 3},
    {"rule": "min-evidence-per-node", "min": 1},
    {"rule": "field-non-empty", "field": "metric"}
  ]
}

This is the part many AI teams miss. A model alone is not a service system. An agent without an evidence discipline is not an operant resource I should trust in a serious design practice. ASD earns that trust by giving the operant side structure: explicit methods, bounded roles, review gates, and receipts.

Value Co-Creation and Value-in-Context

SDL’s most useful warning is that firms do not deliver value unilaterally. They participate in value co-creation, and the beneficiary determines value in context. That point lands with force in servitization work because outcome promises collapse the distance between the provider’s internal logic and the customer’s lived reality.

Aurora Vento is the clearest example in the ASD corpus. The company is a fictional composite industrial vendor trying to move from capital-equipment sales into uptime and performance partnerships. A goods-dominant response would focus on more telemetry, better dashboards, and more premium service bundles. An SDL response starts elsewhere: what does the customer plant actually experience as value, what resources must both sides contribute, and which interactions are true co-creation moments rather than backstage facilitation?

The Aurora Vento case makes the distinction concrete. The customer did not want “insights.” The customer wanted stable production windows, lower emergency freight, faster mean time to repair, and credible planning confidence. Aurora could propose a value architecture, but it could not honestly promise to deliver value in isolation because part of the outcome depended on shutdown windows, operator behavior, data freshness, and shared review cadence inside the plant.

ASD supports this logic because its methods and artifacts keep asking what the beneficiary must do, what the provider must do, and what evidence shows the relationship is working. In the Aurora story, the operating model becomes a shared gameboard rather than a vendor dashboard. The Measurer does not merely chart internal service metrics. The Measurer structures a value-in-context system that both sides can use to judge whether the partnership is actually helping the plant.

That is why the service blueprint matters in SDL terms. A blueprint is more than a provider process map. It is a co-creation map that makes frontstage interactions, backstage work, support systems, customer actions, and agent decision logic visible together. If the customer action lane is thin, the blueprint is probably hiding a value fantasy. If the review cadence is missing, the partnership is probably wishful thinking dressed as transformation.

SDL also clarifies why ASD preserves bounded host claims. Host execution itself is not the value. The service value appears when the host lets the team perform better co-creation work. Claude Code, MCP, BUZZ, and DSH are distribution mechanisms. The value lies in the improved design and operational decisions they help people make together.

The Service Profit Chain, Instrumented

The Service Profit Chain becomes much more concrete once I stop treating it as a motivational poster and start treating it as a measurement problem. Internal service quality shapes employee satisfaction and capability. That in turn shapes external service value, customer loyalty, and financial performance. In agentic work, internal service quality includes the quality of the decision-support system itself: evidence hygiene, method reliability, review fidelity, and whether frontline people receive better cognitive leverage or just more automated noise.

This is exactly where kpi-tree-design matters. A KPI tree forces the team to move from grand claims to causal structure. What is the beneficiary-defined outcome? Which drivers influence it? Which leading and lagging indicators signal movement? Which branches are controllable? Which are shared? Which metrics are vanity? The method turns the Service Profit Chain from theory into an inspectable artifact.

north_star:
  metric: uptime_in_agreed_window_pct
  beneficiary: plant_maintenance_team
  baseline: 92.1
  target: 98.0
branches:
  - metric: mean_time_to_repair_days
    driver_of: uptime_in_agreed_window_pct
    baseline: 5.2
    target: 3.0
    evidence: [ops-log-12, telemetry-07]
  - metric: first_time_fix_pct
    driver_of: mean_time_to_repair_days
    baseline: 61
    target: 75
    evidence: [service-orders-q2]
  - metric: emergency_freight_incidents
    driver_of: mean_time_to_repair_days
    baseline: 14
    target: 5
    evidence: [parts-audit-02]
review_gate: critic

Once a team has that artifact, the Service Profit Chain stops being vague. Internal quality can be expressed as things like evidence freshness, method completion, field readiness, or tooling coherence for frontline teams. Employee capability can be linked to faster diagnosis, fewer handoff failures, lower rework, or clearer decision rights. External value can be observed through customer effort, uptime, resolution trust, or renewal behavior. Profit outcomes then become the downstream consequence of a designed and measured service system rather than a heroic hope.

Aurora Vento is useful again here because the company’s servitization move only works if internal quality improves first. If dispatch planning remains chaotic, if technicians lack the right part logic, if shared review rituals do not exist, then no amount of contractual language will create customer value. The Service Profit Chain reminds me that the backstage experience for staff and partners is part of the product. In ASD terms, that means the Measurer and the Critic become essential business roles, not reporting accessories.

This is why AI deployed only as a cost-cutting device often backfires. If the agent layer strips discretion, floods people with low-trust output, or hides accountability, internal quality deteriorates. The Service Profit Chain predicts the rest: frontline capability falls, customer value thins out, loyalty erodes, and the business calls the transformation disappointing. ASD tries to avoid that trap by using agents to strengthen the internal service system rather than to bypass it.

SDL Commitments in the Platform Contract

The final question is whether the theory actually shows up in the platform contract. I think it does, and I can say exactly where.

First, SDL’s insistence on value-in-context appears in the evidence discipline. Every consequential claim in ASD must connect to evidence, because the system refuses to treat internal conviction as beneficiary truth. Second, operant-resource logic appears in the role model and method surface. Roles are specialized competences. Methods are executable routines for applying those competences. Third, value co-creation appears in the artifact model itself: journeys, stakeholder maps, ecosystem maps, and blueprints all force the team to represent multiple actors and their relationships, rather than provider activity alone.

Fourth, the Service Profit Chain appears in the measurement surface. KPI trees, audits, and baselines force the system to make internal quality and external value legible. Fifth, institutional arrangements show up in the human gate. A phase-advance receipt is not bureaucracy for its own sake. It is the explicit institutional act that says a sponsor, service lead, or governance body is prepared to own the next commitment.

Even the Critic supports SDL. A veto is not merely a software safeguard. It is a protection against the provider-centric fantasy that a team can announce value without properly grounding it. The review-veto-log records where the system overreached. That is operational humility written into the platform.

{
  "projectId": "aurora-vento-808ed8c3",
  "toPhase": "develop",
  "idempotencyKey": "gate-define-1",
  "approvalReceipt": {
    "receiptId": "gate-define-1",
    "decision": "approve",
    "rationale": "Value proposition, KPI tree, and co-creation boundaries accepted.",
    "approvedBy": "service-lead",
    "approvedAt": "2026-08-23T15:30:00Z"
  }
}

That object is more than a control artifact. It formalizes what SDL has always implied: service systems move when actors commit resources under real institutional conditions. An LLM cannot will that commitment into existence. It can only help the organization prepare for it honestly.

This is where ASD earns its theoretical seriousness. The platform does not bolt service design language onto generic AI tooling. It encodes service-dominant commitments into the execution path: evidence before assertion, roles as competences, artifacts as provisional value propositions, review before promotion, measurement tied to value-in-use, and human authority at consequential boundaries.

So when I say agent teams fit service-dominant practice, I do not mean they are fashionable companions for workshops. I mean they can act as operant resources inside a rigorously designed co-creation system. They help me research faster, synthesize deeper, instrument the Service Profit Chain, and challenge weak claims earlier. They do not abolish the beneficiary. They do not replace the institution. They do not nullify the designer. They sharpen all three.

That is the practical force of SDL inside ASD. It keeps the platform from becoming a very fast artifact factory. It keeps the work oriented toward lived service outcomes, shared operating routines, and measured value in context. Without that lens, agentic service design would degenerate into output theater. With it, the system becomes a serious instrument for designing and governing services that people can actually use, trust, and improve.