Case Study: Coze

An all-in-one AI agent (Bot) development platform from ByteDance. The international version, Coze, launched as a trial in November 2023, and the China version followed with its official release on February 1, 2024 (InfoQ interview with the Coze lead). Users build a bot without writing code — arranging prompts, plugins, workflows, and knowledge bases in a visual interface — then publish it with one click to channels like Doubao, Feishu, and WeChat.

The earlier case studies on this site — Case Study: Claude Code, Case Study: LangGraph, Case Study: SWE-agent — all examined "harnesses for developers": the harness is code, software you can fork, hack on, and deploy. Coze is a different species: the harness itself has been packaged as a SaaS product. Every concept you read about in Anatomy of the Harness — the loop, tools, memory, planning, subagents, permissions — maps to a visible, clickable product feature in Coze. That makes it the best specimen for watching how harness concepts get productized.

The argument of this article: Coze is an attempt to collapse the entire harness design space into a graphical interface — it wins unprecedented accessibility at the cost of taking decisions away from developers and handing them to the platform's preset menus. That trade pays off handsomely in customer support, marketing, and office automation; on open-ended tasks it hits the ceiling fast.

A Component Catalog You Can Click

The best way to read Coze is to check it item by item against the component inventory in Anatomy of the Harness. Nearly every item has a matching product feature:

Harness component	Form it takes in Coze	Corresponding chapter on this site
Prompt / persona	The "Persona & Reply Logic" text box in the orchestration panel	Context Engineering
Tool system	Plugin store (official + third-party plugins), custom plugins	Tools & MCP
Planning	Workflows (human-preset flows) + the single agent's autonomous loop	Planning & Task Decomposition
Knowledge base (RAG)	Upload documents → automatic chunking, vectorization, recall testing	Memory Systems
Memory	Three tiers: variables, databases (structured tables), long-term memory store	Memory Systems
Subagents	Multi-agent mode: connect multiple agent nodes on a canvas	Subagents & Multi-Agent Orchestration
Loop	The built-in chat-and-tool-call loop of single-agent mode	The Agent Loop
Observability	Trial-run panel, run details, the Coze Loop evaluation platform	Evaluation & Observability
Permissions / publishing	Channel review, team-space collaboration, API authentication	Permissions, Safety & Human-in-the-Loop

The open-source README of Coze Studio has a line that captures the design intent: inside Coze, workflows, plugins, databases, knowledge bases, and variables are collectively called "resources" — that is, things that are architectural decisions in a code-based harness are abstracted in Coze into assets you can create, manage, and attach. This is the core move of platformization: turning architecture problems into asset-management problems.

Three Control Flows: Workflow, Single Agent, Multi-Agent

Coze's orchestration capability comes in three tiers, matching the spectrum of control-flow freedom — lowest to highest — in Planning & Task Decomposition:

1. Workflow — a human-drawn DAG. Drag nodes onto a visual canvas: LLM nodes, plugin nodes, code nodes (JavaScript/Python supported), knowledge retrieval, conditional branches, loops. The flow is defined entirely by a human; the model only does understanding and generation inside the LLM nodes. This is the "workflow" pole Anthropic describes, and it is Coze's workhorse for deterministic business tasks (data-collection forms, fixed-step content production lines).

2. Single agent — a built-in free loop. The default mode: persona prompt + plugins + knowledge base, with the model deciding on its own when to call a plugin, when to query the knowledge base, and when to reply. The platform neither provides nor exposes the loop's internal structure; your only levers are the prompt and natural-language descriptions of "when each plugin should fire."

3. Multi-agent mode — a routing-and-division-of-labor graph. As the official docs describe it: add multiple agent nodes on the canvas and wire them up, each with its own prompt, plugins, and workflows; the "Start" node dispatches tasks based on the user input and each node's description of its applicable scenario (official Coze docs: multi-agent mode). At bottom this is a visual take on the supervisor routing pattern — kindred to LangGraph's graphs, except that the edges mean "task handoff" rather than "state transition."

Coze's three tiers of control flow (freedom increases, controllability decreases):

 Workflow                  Single agent              Multi-agent
┌─────────┐             ┌──────────────┐            ┌──────────┐
│ LLM node│             │ Persona      │            │  Start   │
│    ↓    │             │  prompt      │            │(routing) │
│ Plugin  │             │      ↓       │            └────┬─────┘
│  node   │             │ built-in loop│                 │ by "scenario fit"
│ Code    │             │ ↓         ↑  │            ┌────┴────┐
│  node   │             │ plugin calls │            ▼         ▼
│Condition│             └──────────────┘         Agent A   Agent B
└─────────┘              Platform owns         (own persona/plugins/
 Human defines           the loop, you set      workflows)
 the flow                the persona            the model picks the handoff

A notable absence

All three tiers lack the interleaved planning of Claude Code, where the model maintains its own todo list and decides its own step cap. Coze's agent loops within a single conversation, but cross-session planning state and reviewable plan artifacts are nowhere on the product menu. Low-code platforms would rather push "task structure" up front to the builder as a drawn diagram (workflows) than leave the runtime model room to improvise — which fits perfectly with its target users, who aren't engineers.

Plugins, Knowledge Base, Memory: Components Made into Products

Plugins = a managed marketplace for the tool ecosystem. Coze turns tools into a plugin store: official plugins cover web search, image understanding, document processing, and other common capabilities, and third-party developers can wrap their own APIs as custom plugins and list them there. Compare Claude Code's tool philosophy — "give the model grep and bash and let it combine them" — Coze is the extreme in the other direction: every tool is packaged as a product card with form-field parameters, and the model just fills in the slots. That makes tool-call success rates far more forgiving of weaker models, but it also means the boundary of your tool capabilities is the store's shelf — anything not on the shelf, you have to write code to wrap yourself.

Knowledge base = one-stop RAG. Upload PDFs, web pages, or spreadsheets and the platform handles chunking, vectorization, and indexing automatically, with a recall-testing panel; knowledge comes in three formats: text, tables, and photos. The engineering decisions from the components chapter — "retrieval strategy, chunk size, embedding choice" — get compressed into a few toggles.

Memory = three explicit product tiers. Variables (key-value pairs scoped to a session), databases (structured tables whose rows the model reads and writes in natural language — what the official docs call the database storage capability of long-term memory), and long-term memory (the newer memory store, with storage and recall isolated per user UID; see the official docs). The three tiers line up with the classic layering in Memory Systems — "working memory / structured state / persistent facts" — and Coze is probably the first mass-market product to ship that layering as a GUI.

What productization gives and takes

Platform packaging is a great kindness to its target users: an ops person who can't code can still assemble a support bot with RAG and database-backed memory. But the same move is a straitjacket for engineers — you can't swap the embedding model, can't customize reranking, can't inspect the prompts inside the loop. The flip side of "zero configuration" is "not configurable," and that is the structural trade-off of every platform-style harness.

Model Binding and the Two-Version Split: Vertical Integration in the ByteDance Ecosystem

Coze's model layer is the key to its business logic:

• The China version defaults to the Doubao model family (early on, ByteDance's in-house Skylark). After the February 2025 billing change, new agents and workflows default to "the Doubao models generally available on the Coze platform," and other models on Volcengine Ark must be manually enabled and switched to (official billing announcement). Model costs are billed centrally by the platform — Coze is the distribution front end for Doubao/Volcengine models.
• The international version plugs into models such as GPT-4 and GPT-3.5, and the publishing channels switch to Discord, Telegram, and other global platforms (differences between the China and international versions). The China version's channels put ByteDance's own ecosystem first: Doubao, Feishu, WeChat official accounts and customer service, Douyin, Juejin, mini-programs, plus API and Chat SDK (launch coverage, a channel rundown).

The publishing channels deserve a second look through the harness lens. For a code-based harness, "delivery" is a deployment script; Coze's delivery is channel binding — once the bot is built, one click puts it inside the Doubao app, a Feishu group chat, or a WeChat official account. For the business side, the harness's last mile (reaching users) is eliminated by the platform; for the platform, that's also the hook that locks developers into ByteDance's distribution system.

Pricing: Pay per Call, Not per Seat

Coze's monetization follows the classic cloud-vendor playbook (official billing announcement, Volcengine Pro console):

• The basic tier is free with quota limits, aimed at individuals trying things out;
• The Pro tier is pay-as-you-go postpaid: agent calls at ¥0.002 each, knowledge bases free up to 10GB, model tokens billed at Doubao rates, plus a free daily allowance of 500 resource points (same-day expiry), all deducted against a unified "Coze resource pack";
• Billing responsibility is split: once an agent that uses Coze's official models is published to the store, usage is billed to the person who invokes it — developers don't pay for their own users — the classic platform play of subsidizing the supply side to grow the ecosystem;
• The international version, by contrast, runs a subscription-and-credits model aimed at individual developers (Premium lite / Premium / Premium plus tiers; see an in-depth teardown of ByteDance's Coze).

On July 26, 2025, ByteDance went a step further and open-sourced the core engines: Coze Studio (the development platform) and Coze Loop (the prompt debugging and evaluation platform) landed on GitHub under Apache 2.0 — Golang on the back end, React + TypeScript on the front end, a workflow canvas built on the open-source FlowGram engine, an agent runtime built on CloudWeGo's Eino framework, and self-hosted deployment possible on as little as 2 cores and 4GB of RAM. Open source answers the "what if I'm locked into a platform-style harness" worry — you can pick up the entire low-code harness and carry it back to your own machine room.

Platform-Style vs. CLI-Primitive: The Two Poles of the Design Space

Set Coze next to Claude Code and you see the widest stretch of the harness design spectrum. Both are "successful agent products," but they give opposite answers to the same question:

Dimension	Coze (platform-style)	Claude Code (CLI primitives)
What the harness is	Hosted SaaS, configured through a GUI	A local process, code + text files
Who the user is	Ops, product managers, small merchants	Engineers
Control flow	Human-drawn workflows / built-in loop / multi-agent graph	One main loop, the model in charge
Tools	Plugin store, form slot-filling	Unix primitives like grep/bash
Memory	Variables/databases/memory store, managed in a GUI	One Markdown file
Models	Platform-bound (Doubao), barely swappable	Its own model, but harness and model are separate layers
Extension boundary	Custom plugins, code nodes, API	The whole shell ecosystem, MCP, hooks
Distribution	One-click publishing to channels (Doubao/Feishu/WeChat)	No distribution layer; embeds into CI/scripts
Debugging failures	Trial-run panel showing node inputs and outputs	Read traces, tweak prompts, change code
Capability ceiling	The platform's menu	Model capability × user imagination

The disagreements in this table reduce to a single choice: who carries the complexity. Coze pulls complexity into the platform (retrieval, loops, and memory handled internally), and what users see is a menu; Claude Code pushes complexity out to the model and the user, and the product stays razor-thin. The first bets that "the overwhelming majority of needs are templated"; the second bets that "open-ended tasks are worth more, and models will only get stronger."

Where the low-code harness ceiling lies

Coze's shape makes three ceilings plainly visible. First, open-ended tasks can't be expressed: a workflow requires that you can draw the flowchart in advance, and tasks like "research this topic for me" or "fix this bug" have no flowchart to draw — the same bind discussed in Case Study: LangGraph, with low code amplifying it. Second, debugging depth is limited: when a bot misbehaves, what you can tune are prompts and toggles; the inside of the loop is invisible — the black box is far bigger than in a code-based harness. Third, the model dividend can't be fully captured: platform-bound models and packaging mean a new model's native abilities (longer context, stronger autonomous planning) wait until the platform reworks its menus, while a thin harness benefits almost instantly (exactly the dynamic discussed in Model vs. Harness). ByteDance's own response is telling: in April 2025 it launched Coze Space (a general-purpose autonomous agent positioned against Manus; see the product iteration timeline), and across the 2.0/3.0 releases from late 2025 the platform has kept evolving toward "agents that autonomously complete long-running tasks" (a feature roundup of Coze versions) — spinning up a free-form agent product line beside the templated platform amounts to an official admission that the ceiling exists.

A Decision Framework: When a Platform-Style Harness Is the Right Call

Q1. Can the builder write code?
    ├─ No / doesn't want to ─────────────→ platform-style is the only realistic option
    └─ Yes, and the task is open ────────→ a code-based harness has a higher ceiling

Q2. Can the task's flow be drawn up front?
    ├─ Yes (support, forms, pipelines) ──→ workflow: controllable, auditable, cheap
    └─ No (research, coding, exploration) → free-form agent; don't force-fit a platform

Q3. Do you need channels that reach end users?
    ├─ Yes (Doubao/Feishu/WeChat ecosystems) → the platform's distribution value > lock-in cost
    └─ No (internal tools/CI) ──────────→ self-built harness + API is freer

Q4. Are data compliance and private deployment hard requirements?
    ├─ Yes ─────────────────────────────→ self-host the open-source Coze Studio, or build your own
    └─ No ──────────────────────────────→ hosted SaaS is simpler

The anti-pattern is just as clear: don't cram an open-ended task into a workflow just because Coze lets you build it — you'll get a monster with dozens of nodes and "LLM fallback branches" everywhere, and maintaining it will cost far more than writing the code yourself. The success stories on the platform are almost always the pairing of "highly deterministic process + a genuine need for distribution channels." That's no coincidence.

Further Reading

• Anatomy of the Harness — the component framework this article checked item by item
• Case Study: Claude Code — the other end of the spectrum: a CLI-primitive harness
• Case Study: LangGraph — the code world's "draw a flowchart" school, the mirror image of Coze's workflows
• Case Study: Dify — another route within open-source low-code platforms
• Tools & MCP — the full argument for the plugin store vs. Unix primitives
• Planning & Task Decomposition — where workflows and autonomous loops sit on the spectrum
• Memory Systems — the layering theory behind variables/databases/long-term memory
• Subagents & Multi-Agent Orchestration — the general design questions behind multi-agent mode
• Model vs. Harness — the pros and cons of platform-bound models
• Design Principles — the transferable trade-offs distilled from this case

References

• Official Coze docs: multi-agent mode — start-node dispatch, scenario fit, per-node configuration
• Official Coze docs: Pro billing rules adjustment — resource points, resource packs, Doubao as the default model, who gets billed
• Official Coze docs: long-term memory — the memory store, per-user UID isolation
• Volcengine: Coze Pro purchase page — pricing details such as ¥0.002 per call
• GitHub: coze-dev/coze-studio — the open-source repo, Apache 2.0, the tech stack (Golang/React/Eino/FlowGram), the "resources" concept
• InfoQ: Coze announces open source — exclusive interview with the lead (July 2025) — the 2023 international trial, the February 2024 China launch, the open-source decision
• iheima: ByteDance's take on GPTs, "Coze," goes live (February 2024) — the China launch, Doubao/Feishu/WeChat channels
• CSDN: Coze tutorial — China vs. international version differences — Skylark vs. the GPT family, the two sites
• An in-depth teardown of ByteDance's Coze (long-form product analysis) — the international subscription-and-credits model, how the China and international paid models differ
• AI Tool Collection: a feature roundup of Coze — Coze 2.0/3.0, Agent Plan, long-term memory, and other product evolution
• Juejin: the complete hands-on guide to Coze (with an iteration timeline) — key milestones such as the April 2025 Coze Space public beta and the July 2025 open-sourcing
• Tang Shiye: Coze agent publishing channels — a rundown of channels including the Coze store, mini-programs, and Juejin