Are AI Agents a Work Necessity? A Technical Breakdown of Stickiness and Moats
This article examines why a headline daily-active-user number does not prove that an AI Agent product has a real moat. It breaks stickiness into four measurable layers (interaction, context, tooling/integration, and governance), offers a rough but usable formula for quantifying switching costs, distinguishes raw model capability from capability productization, and outlines three possible endgames for subsidy-driven growth. It closes with six engineering principles and a selection checklist for building an Agent workflow that stays portable—model-pluggable, asset-exportable, evaluation-driven, and cost-governable—so you are not the side trapped by switching costs.
1. What Ten-Million DAU Actually Tells You: Three Overlooked Premises
A vendor recently announced that one of its AI office assistants surpassed ten million daily active users, and the number quickly became the center of industry discussion. To judge what it means, first break it into three separate things: distribution capability, scenario rigidity, and unit economics. When you mix the three together, you end up with one of two equally hasty conclusions—“Agents have already won” or “Agents are just burning cash.”
First, distribution sets the ceiling. Any product that pushes DAU into the tens of millions within a month rarely does so through organic growth; it rides traffic from an existing high-frequency entry point—instant messaging, an office suite, an OS-level entry, or a free strategy that covers the entire user base at once. This means DAU largely reflects the parent platform’s traffic rather than the product’s own product-market fit (PMF). The test for whether that traffic is real is simple: turn off the subsidies and the entry points, then look at the shape of the retention curve.
Second, scenario rigidity determines retention. The Agent scenarios in genuinely frequent use today cluster around a few categories of “high-frequency, long-tail, medium error-tolerance” tasks: code generation and refactoring, document and email drafting, spreadsheet and data analysis, meeting notes, slide-deck outlines, retrieval-style Q&A, and test-case generation. What these tasks share is low standardization of input and a wide acceptable range for output—users don’t need the model to produce a single correct answer, just a rough seventy-percent draft that a human can polish into something usable. This “draft generation + human convergence” pattern is the fundamental reason Agent tools can drive penetration up.
Third, unit economics determines survival. Every conversation consumes inference compute, and this is the most essential difference from traditional software: a traditional product’s marginal cost of user growth approaches zero, whereas an Agent tool’s active-user growth pushes inference cost up linearly. So “subsidize at a loss to grow the product” is not simply a business miscalculation; it is a classic bet that trades capital for a time window—betting that user assets can be deposited onto your own platform before the subsidies run out.
The conclusion: high DAU only shows that distribution and subsidies work; it says nothing about whether a moat exists. The next question is more technical: what, exactly, is an Agent tool’s stickiness made of?
2. “Agent Tools Have No Stickiness”—Half Right, Half Wrong
The popular view holds that Agent tools have no user stickiness because their core capability is the underlying large model, so users always go with “whichever model works better,” and switching cost is near zero. This view basically holds at the individual-user level but is wrong at the organizational and workflow level. The key is to decompose the vague word “stickiness” into four measurable layers:
| Layer | Concrete form | Switching cost | Typical users |
|---|---|---|---|
| Interaction layer | UI, keyboard shortcuts, prompt templates, personal habits | Very low (hours) | Individual users |
| Context layer | Conversation history, saved code snippets, knowledge base index, personal memory | Low–medium (days) | Heavy individual users |
| Tooling & integration layer | Plugins/tool calls, account systems, permission models, approval and pipeline integration | High (weeks to months) | Teams, R&D organizations |
| Governance layer | Audit logs, data residency and compliance, cost quotas, observability | Very high (hard to migrate) | Mid-to-large enterprises |
This table marks where the original claim holds and where it breaks: individual users truly have almost no stickiness—prompts can be copied, conversation history hardly matters, and switching from one assistant today to another tomorrow is effortless, even running several in parallel. But once an Agent is wired into an enterprise’s workflow, stickiness appears—and what’s sticky isn’t the model, it’s the integration and governance.
Put more fundamentally: an Agent tool’s stickiness = the degree to which user assets are structured × the difficulty of migrating those assets.
- The more structured the assets (structured knowledge bases, versioned skill configurations, executable evaluation sets), the higher the stickiness.
- The more easily the assets can be exported and rebuilt (plain-text prompts, stateless sessions), the lower the stickiness.
So the precise phrasing of “Agent tools have no stickiness” should be: Agent tools have no stickiness at the individual interaction layer and strong stickiness at the integration and governance layers—and today’s consumer products have only reached the first two layers.
3. A Framework for Quantifying Switching Costs
To turn “stickiness” from intuition into a computable engineering quantity, here is a rough but usable estimating formula:
Migration Cost = w_c · context rebuild hours+ w_p · prompt rewrite hours+ w_t · tool & integration reconnection hours+ w_r · workflow rework hours
A sketch implementation:
from dataclasses import dataclass, field@dataclassclass MigrationCost:context_rebuild_hours: float = 0.0prompt_rewrite_hours: float = 0.0tool_reconnect_hours: float = 0.0workflow_rework_hours: float = 0.0# weights are configurable per user group: individual user vs R&D team vs enterpriseweights: dict = field(default_factory=lambda: {"context": 0.5, "prompt": 0.5, "tool": 1.5, "rework": 2.0})def estimate(self) -> float:return (self.weights["context"] * self.context_rebuild_hours+ self.weights["prompt"] * self.prompt_rewrite_hours+ self.weights["tool"] * self.tool_reconnect_hours+ self.weights["rework"] * self.workflow_rework_hours)
This “bill” explains two seemingly contradictory phenomena:
- An individual developer can switch Agent products daily without a second thought, because his
toolandreworkterms are almost zero. - A company that has already wired code scanning, ticket lookup, and release approval into its Agent must redo permission mapping, audit integration, and regression testing to switch vendors—a cost that can run into person-months, far above any subsidy amount.
This yields an important engineering inference: subsidies can only move users on the low-cost terms (context/prompt); they cannot shake the high-cost terms (tool/rework). That is also why “throw money at the market” looks effective on the consumer side but often hits a wall on the B2B side: an enterprise’s primary constraint in vendor selection is not price but integration risk and compliance liability.
4. Is Model Capability the Core Competitive Advantage? Distinguishing “Capability” from “Capability Productization”
The original view holds that an Agent tool’s core competitive advantage lies in the underlying large model. I agree with half of this and need to add the other half.
The part that holds: On several capability dimensions, the gap between frontier models is directly perceivable to users, not marketing spin. Typical examples include cross-file understanding and refactoring of complex codebases, aesthetic control and attention to detail in front-end UI generation, structured writing of long documents, information retention over very long contexts, stability of multi-step reasoning and tool calling, and reliability of structured output. When a heavy user’s output quality depends directly on one such capability, his dependency is real, and switching produces a perceptible drop in output quality—this is the strongest form of “non-contractual lock-in.”
The part that needs adding: The difference users perceive usually comes half from the model and half from product-layer engineering. The same model can deliver experiences that differ by an order of magnitude across products, and the difference comes from:
- Context engineering: how to retrieve, trim, rank, and compress context, and how to manage memory across very long conversations;
- Task orchestration: task decomposition, multi-step planning, failure retry and rollback, and parallel subtasks;
- Tooling reliability: parameter validation for tool calls, idempotency design, timeouts and graceful degradation, and permission boundaries;
- Observability: trace logging, failure attribution, and regression evaluation—this determines how fast the product can iterate;
- Cost engineering: cache reuse, model-tier routing (simple tasks to small models, complex tasks to large models), and batching and streaming strategies.
So the more accurate statement is: model capability sets the ceiling, engineering capability determines the level users actually get, and asset accumulation determines the switching cost. Together the three form the moat; miss any one link and you get either “the model is strong but the product is hard to use” or “the product is great but it collapses the moment you swap the model.”
As for the different paths vendors take, they can be summarized neutrally into three types, whose moats come from different sources:
- Path A: A self-developed frontier model as the core asset. Competitiveness comes from the model’s own capability lead; users come “for the model.” The moat here is capability and iteration speed, but it faces one harsh reality—capability leads come with a window that is usually measured in quarters, not years.
- Path B: Deep integration built on owned compute and an owned ecosystem of applications. When the chip, the model, and the upper-layer applications belong to the same entity, the model can call capabilities within the ecosystem—calendar, docs, email, maps, cloud drive—to achieve “cross-application orchestration.” Conversely, third-party tools that connect only through open APIs often manage just the most basic operations, with deeper capabilities out of reach. This moat is structurally ecological and hard for a single-point product to replicate.
- Path C: Buying scale with traffic entry points and subsidies. Products are highly homogeneous in features, and model capabilities don’t open up a generational gap, so users face no barrier to switching. This path must answer one question: after the subsidies stop, what is left that is defensible? The answer—only the accumulated assets, plus the integration inertia formed once you’re wired into the workflow.
There is also a structural risk often overlooked: when the upper-layer tool and the lower-layer model come from different entities, bargaining power is naturally asymmetric. If the model side raises prices, throttles, or changes its API strategy, the tool side’s cost structure and experience quality take a hit at the same time. This is not a competition problem but a supply-chain structure problem. Conversely, if the upper-layer tool has accumulated enough user assets and workflow integration, it can gain bargaining power over the model side in return. Bargaining power in the value chain ultimately falls to whichever end controls the standards for context and integration.
5. Three Possible Endgames for the Subsidy Model
Combining the analysis above, “subsidizing Agent tools at a loss to grow” could head toward three endgames, and their probabilities are not equal:
Endgame 1: Homogeneous convergence into a price war. Following the evolution of ride-hailing, food delivery, and community group-buying, products fail to open up feature gaps, competition degrades into price and traffic, and after a round of industry shakeout only one or two players remain. To survive this path, the only way out is extreme unit economics: model-tier routing, cache hit rate, context-length control, and layering free quotas against paid capabilities. Without these engineering measures, the larger the scale, the faster the losses.
Endgame 2: Moving up into verticals and workflow depth. Leaving the general-assistant track for specific industries and specific workflows: code review and release pipelines, closed-loop support ticketing, financial reconciliation, first-pass legal contract review, and research literature processing. The moat here comes from domain data, integration depth, and the ability to take on responsibility. Switching costs are extremely high, and this is the direction most likely to form genuine stickiness.
Endgame 3: Being covered by a capability leap on the model side. If one party’s model capability achieves a generational lead, users may migrate wholesale to a product whose core asset is the model. But there is a key reverse constraint: migration difficulty depends on where the user’s assets are deposited. If a user’s skill configurations, knowledge base, and evaluation sets are stored inside a third-party tool, migration cost rises significantly; conversely, if the user manages prompts, tool registrations, and test cases externally, migration is nearly painless.
Overall judgment: whoever controls the “standards for context and tool integration” controls the bargaining power; the side that controls only the entry point and subsidies is fragile over the long run. This is not a moral judgment but an inevitable result of asset structure.
6. Engineering Practice: Building an Agent Workflow Not Bound to a Single Platform
No matter how the industry evolves, the most valuable thing developers can do is give their Agent workflow portability. Here are six directly actionable design principles.
6.1 Layer One: Abstract the Model Interface for Multi-Model Pluggability
Don’t hard-code one vendor’s calling convention directly into business code. Build a unified Provider abstraction that standardizes requests, tool declarations, and usage accounting:
from abc import ABC, abstractmethodfrom dataclasses import dataclass, field@dataclassclass ChatRequest:messages: list[dict]tools: list[dict] | None = Nonetemperature: float = 0.2max_output_tokens: int | None = Nonetags: dict = field(default_factory=dict) # used for cost accounting and tracingclass LLMProvider(ABC):name: str@abstractmethoddef chat(self, req: ChatRequest) -> dict:"""Returns a unified structure: {text, tool_calls, usage, latency_ms}"""@abstractmethoddef health(self) -> bool: ...class Router:"""Selects among multiple Providers by policy, with failover on failure"""def __init__(self, providers: dict[str, LLMProvider], policy: str = "quality_first"):self.providers = providersself.policy = policydef _order(self, req: ChatRequest) -> list[str]:if self.policy == "cost_first":return ["small", "large"]if self.policy == "quality_first":return ["large", "small"]return list(self.providers)def chat(self, req: ChatRequest) -> dict:last_err = Nonefor name in self._order(req):provider = self.providers.get(name)if provider is None or not provider.health():continuetry:return provider.chat(req)except (TimeoutError, RateLimited) as err: # fall back only on retryable errorslast_err = errcontinueraise RuntimeError(f"all providers failed: {last_err}")
The direct payoff: model selection becomes a configuration item rather than a code change. Canary rollouts, A/B comparisons, and cost optimization all happen without touching business logic.
6.2 Layer Two: Manage Tools and Skills Declaratively, Versioned and Externalized
Define a “skill” as a combination of a config file + prompt templates + a tool manifest, kept in a version-control repository and decoupled from the runtime platform:
# skills/weekly-report.yamlname: weekly-reportversion: 3description: Summarize the current sprint's progress and generate a weekly report draftinputs:- repo_url- sprint_idtools:- git_read- issue_query- doc_writerprompt_ref: prompts/weekly-report@v3constraints:max_output_tokens: 2000require_citation: true # enforce source citations to reduce hallucination riskallowed_data_scope: [repo, issue] # explicit data boundaries
The point is that tools declares capability semantics, not a specific platform’s interface names. As long as you hold that abstraction, switching platforms requires replacing only the tool-adapter layer; the skill definition itself stays untouched.
6.3 Layer Three: Context as Snapshots, Exportable and Rebuildable Anytime
Conversation memory, RAG indexes, user preferences, and skill version history all live in your own storage, with the platform serving only as a runtime. The test is plain: if the platform shut down tomorrow, could I rebuild the same workflow from exports within a day? If yes, you’re safe; if not, you’re subsidizing the platform.
6.4 Layer Four: Evaluation First—Turn “Which Model Is Better” from a Feeling into Data
This is the fundamental way to counter “the experience collapses when the model changes.” Build a three-tier evaluation:
- Offline evaluation set: extract 100–300 cases with reference answers or scoring points from real tasks, covering typical and edge scenarios; run them every time you change model, prompt, or context strategy.
- Metric design: task completion rate, tool-call success rate, format-compliance rate, human usability score (1–5), average token consumption, and P95 latency.
- Online A/B and trace analysis: compare by user bucket in production, while retaining full call traces (input context summaries, tool-call sequences, outputs, and the human-edit diff) for failure attribution.
Sketch:
def evaluate(cases, agent, k=3):results = []for case in cases:scores = []for _ in range(k): # sample multiple times to avoid misjudgment from randomnessout = agent.run(case.input)scores.append(score_case(case, out)) # completion / format / human scoreresults.append({"id": case.id,"mean": sum(scores) / len(scores),"variance": pvariance(scores),"tokens": out.usage.total_tokens,})return summarize(results) # return summary metrics for cross-model comparison
With this in place, model selection is no longer “I heard model X makes nice front-ends” but a reproducible comparative conclusion—this is both a matter of technical rigor and the strongest chip you can bring to the negotiating table.
6.5 Layer Five: Cost Governance and Quotas
- Unified metering: tag token consumption by team, project, and task type to form a shareable cost view;
- Tiered routing: classify intent up front, send simple tasks to small models, and call large-parameter models only for complex tasks;
- Caching and reuse: cache repeated Q&A on the same document and system prompts with identical prefixes;
- Budgets and alerts: set daily/monthly quotas and auto-degrade or throttle near the threshold, so an abnormal loop doesn’t blow up the bill;
- Context slimming: trim irrelevant history and compress redundant information—long context is not the same as good context, and it simultaneously raises quality risk and cost.
6.6 Layer Six: Hard “Exportability” Criteria for Platform Selection
Put the following items into your selection scorecard instead of judging only by demo quality: whether prompts and skill configs can be exported, whether sessions and knowledge bases can be exported in bulk, whether evaluation sets and trace logs can be exported, whether models can be hot-swapped without changing business code, and whether permissions and auditing meet your own compliance requirements. These criteria determine whether the w_t and w_r terms in the migration-cost formula are near zero or run into person-months.
For a cloud deployment, the safer approach is to split capabilities into independent components rather than buying an “all-in-one black box”: model service and inference resources, a containerized runtime, object storage, a message queue, logging and monitoring/alerting, and permissions and auditing—each deployed, scaled, and replaced independently. These general-purpose capabilities are standard offerings on public clouds. Baidu AI Cloud, for example, provides model services, container and inference resources, object storage, logging, and monitoring/alerting, and can serve as one reference implementation of this layered architecture—the point isn’t which vendor you pick, but whether the architecture allows replacement.
7. Selection Checklist
- Is the model layer already abstracted, so switching models requires no business-code changes?
- Are skills/prompts versioned and stored externally?
- Can knowledge bases and conversation memory be fully exported?
- Is there an offline evaluation set and a failure-attribution mechanism?
- Do tool calls have timeouts, retries, idempotency, and permission checks?
- Is there token-level cost metering and quota alerting?
- Does it meet data residency, audit-trail, and masking requirements for compliance?
- Do critical scenarios have a human fallback (an Agent failure doesn’t block the main flow)?
8. Conclusion: Is an AI Agent a Work Necessity?
It’s more useful to answer per audience than to give one sweeping conclusion:
- For developers and data-analysis roles, it’s already close to a necessity. Code completion, refactoring, test generation, scripting, SQL, and data cleaning have entered the main line of daily workflows, and the drop in efficiency from leaving them behind is obvious and measurable.
- For content, operations, and functional roles, it’s a strong assist but the process isn’t closed-loop. Output quality and factual accuracy still need human gatekeeping, and in most scenarios the Agent provides a “draft” rather than independently owning end-to-end delivery.
- For enterprise scenarios, whether it’s a necessity depends on integration depth. As long as the Agent stays a “chat box for asking questions,” it’s just a tool; once it’s wired into ticketing, code repositories, approval flows, and monitoring alerts—and takes on responsibility—it becomes infrastructure, and switching costs climb steeply.
Back to the opening question: is buying the market with subsidies a mistake? The more accurate statement is that subsidies can buy trials and momentary scale, but not stickiness; model capability sets the ceiling, engineering capability determines delivery quality, and asset accumulation plus a portable architecture determine long-term bargaining power. For individual developers and enterprise technical teams alike, the most worthwhile investment isn’t betting on a single product, but building an Agent workflow that is “model-pluggable, asset-exportable, evaluation-driven, and cost-governable”—so that whether the industry heads toward subsidy shakeout, vertical deepening, or a capability leap, you won’t be the side trapped by switching costs.
