The Agent Handbook

Appearance

Coze

At a glance ByteDance's low-code agent building platform: bot orchestration, plugins, workflows, knowledge bases, and multi-channel publishing in one place; coze-studio and coze-loop open-sourced in July 2025, with Coze 3.0 pivoting to multi-agent collaboration in 2026. This page dissects its capabilities, inferred architecture, pricing, and the boundaries with Dify/n8n.

This page contains time-sensitive content; data is current as of 2026-08. Job listings, pricing, and product features may have changed — verify against the original sources before citing.

Coze ​

If LangGraph represents the "engineers hand-write code to build agents" route, Coze represents the other road: turning agent building into a visual product, so that non-coders—operations staff, product managers, teachers, content creators—can assemble a working agent in half an hour. It is currently China's largest low-code agent platform by users, and one of the best specimens for observing "agent productization."

The goal of this page is not to teach you which buttons to click (official tutorials are plentiful); it is to answer three questions from an engineer's perspective: what exactly is Coze's architecture, which agent engineering problems has it hidden inside the product, and when should your team use it—and when go around it.

1. Positioning: ByteDance's All-in-One Low-Code Agent Platform ​

Coze is ByteDance's AI application development platform, with the core narrative of "drag + configure" to build an agent, then one-click publish to every channel. First, clarify the product matrix, because "Coze" refers to different things in different contexts:

ProductPositioningForm
Coze development platform (coze.cn / coze.com)The low-code agent/app building platform; the protagonist of this pageSaaS, China and international editions
Coze SpaceA general agent for end users (Manus-like), beta from April 2025SaaS
Coze LoopAgent evaluation, observability, and tuning platformSaaS + open source
EinoA Go LLM application orchestration framework (from the CloudWeGo family)Open-source framework
coze-studio / coze-loop (open-source editions)The open-source releases of the two products aboveApache 2.0, self-hostable

The timeline is roughly: coze.com launched overseas in November 2023; the China edition coze.cn launched in February 2024 (connected to the Doubao models); Coze Space entered beta in April 2025 to benchmark general agents; Coze Studio and Coze Loop were open-sourced on July 26, 2025; and Coze 3.0 launched on June 1, 2026, pivoting to multi-person + multi-agent collaboration.

One thing to note: the China and international editions are nearly two separate products. The China edition connects to domestic models like Doubao/DeepSeek by default and publishes into the Doubao/Feishu/WeChat ecosystems; the international edition connects to GPT, Gemini, and other models and publishes to Discord, Telegram, and similar channels. Accounts, plugin ecosystems, and template marketplaces are not shared between the two—don't mix them up when selecting.

Why ByteDance Built Coze

For ByteDance, Coze is a "distribution channel" for the Doubao models—every conversation of every bot on the platform consumes Volcano Engine model calls. That explains the nearly-free early strategy and the 2026 full pivot to subscription plans + credit-based billing. A platform's pricing logic has always been tied to the underlying models' cost structure; keep that in mind when estimating costs (see Cost & Optimization).

2. Core Capabilities ​

Bot Orchestration: Single-Agent and Multi-Agent Modes ​

Coze's basic unit is the "agent" (Bot). The core decision when creating a Bot is choosing the orchestration mode:

  • Single agent (LLM mode): one persona prompt ("Persona & Reply Logic") plus attached skills (plugins, workflows, knowledge bases), with the model autonomously deciding when to call what. The most common mode.
  • Single agent (workflow mode): the bot's replies are strictly determined by a workflow, with the model only acting inside nodes. Suited to customer-service scripts and compliance Q&A where improvisation is not allowed.
  • Multi-agent mode: a "host" agent handles intent recognition and task dispatch, routing requests to multiple specialized sub-agents that collaborate, each with its own persona, skills, and memory. Essentially the supervisor pattern from Multi-Agent Architecture productized as a feature; Coze 3.0 in 2026 further made "one person + multiple agents / multiple people + multiple agents" project collaboration a headline capability.

The persona prompt area supports variables and skill-description injection; the platform automatically assembles the descriptions of available plugins/workflows into the system prompt—classic productization of prompt engineering: users see a "Persona & Reply Logic" text box, while underneath runs a prompt-template assembly pipeline.

The Plugin Ecosystem ​

Plugins are Coze's tool layer, corresponding to the function calling in Tools & MCP. Three sources:

  1. Official plugins: hundreds of ByteDance-maintained tools (search, maps, image generation, Feishu Base, Toutiao news, etc.), working out of the box;
  2. Custom plugins: provide an OpenAPI description (or just fill in URL + auth), and the platform wraps any HTTP API into a tool;
  3. Workflows as plugins: any workflow can be invoked as a tool by a bot, and can also be published as an MCP service for Coze Space or external agents.

The plugin marketplace's ecosystem logic resembles GPTs Actions, but the execution experience is much better—because ByteDance controls both the model (Doubao's function-calling capability) and the platform (parameter extraction, error retries), the whole chain can be optimized in-house.

Workflows: Coze's Real Moat ​

With only "persona + plugins," Coze would just be a prettier ChatGPT wrapper. Workflows are its core asset: a visual DAG orchestrator whose node types include LLM, code (JavaScript/Python), plugins, knowledge retrieval, conditional branches, loops, messages, databases, intent recognition, and more, with streaming output and batch runs supported.

From an engineering viewpoint, a Coze workflow ≈ a low-code exoskeleton of the Agent Loop: it takes "when to call the model, when to call tools, how data flows" out of the model's autonomous decisions and turns them into deterministic orchestration. That's why complex businesses almost all converge on "workflow mode"—controllability is worth more than autonomy.

User input
   │
   ▼
┌──────────────┐   Intent recognition node
│ Intent       │────────┐
│ recognition  │        │
└──────────────┘        ▼
   │              ┌───────────┐
   ▼              │ Chit-chat │
┌──────────┐      │ LLM       │
│ Condition│      └───────────┘
│ branch   │
└──────────┘
   │ business intent
   ▼
┌──────────────┐    ┌──────────────┐    ┌─────────────┐
│ Knowledge    │ →  │ LLM node     │ →  │ Code node   │ → output
│ retrieval    │    │ (answer      │    │ (formatting/│
│ node (RAG)   │    │  generation) │    │  validation)│
└──────────────┘    └──────────────┘    └─────────────┘
        ▲
        │ failure fallback
┌──────────────┐
│ Handoff to   │
│ human / fixed│
│ script       │
└──────────────┘

Since April 2025, workflows can be published with one click as MCP extensions, callable directly by Coze Space or any other MCP-capable client—turning "Coze workflows" from internal platform assets into outward-facing service capabilities.

Knowledge Bases and Memory ​

The knowledge base is the platform's built-in RAG: it supports two types, text (PDF/Word/web pages/Feishu docs/Notion, etc.) and tables, with automatic segmentation (custom rules also supported), vectorization, and hybrid retrieval, with selectable recall strategies and top-k. For non-technical users this is a killer feature; engineers should know its boundaries—segmentation strategy and retrieval parameters are adjustable but not programmable, complex multi-path recall and rerank fine-tuning are out of reach, and for those needs you should build your own RAG pipeline.

For memory it provides variables (user-profile KV), long-term memory (facts extracted from conversations), and databases (structured tables that bots can read and write), corresponding to the short-term/long-term/structured three layers in Memory Systems—but all are platform-hosted black boxes.

Publishing Channels ​

One-click publishing is another core selling point. The China edition supports publishing to the Doubao app, Feishu (bots/Base), WeChat official accounts, WeChat customer service, Douyin enterprise accounts, Juejin, plus Web SDK / API (Chat SDK + OpenAPI); the international edition corresponds to Discord, Telegram, Messenger, LINE, and so on. The channel adaptation layer (message formats, auth, session management) is fully platform-hosted—exactly where a low-code platform's biggest efficiency advantage over self-building lies.

Stores, Templates, and Coze Space ​

Above the platform sits a layer of "ecological niche" design, often overlooked through a purely technical lens:

  • Bot store and templates: users can publish finished bots, workflows, and plugins to the store for others to copy (fork-style reuse); the official side lowers cold-start barriers with templates and case studies. In 2026 the skills store expanded to hundreds of official industry skills (legal, finance, e-commerce, education, etc.) and added support for packaging personal SOPs into custom skills.
  • Coze Space: the general agent product that entered beta in April 2025, positioned against Manus—task automation, an expert agent ecosystem, and MCP extension integration (the first batch integrated 60+ MCP extensions including Feishu Base, Amap, and speech synthesis). Its relationship with the development platform is "consumer side / producer side": developers build workflows and plugins on the Coze development platform and publish them as MCP services, which become capability supply for Coze Space. This is ByteDance's entry-point positioning against the "agent operating system."
  • Coze 3.0 (June 2026): the headline is collaboration—project spaces with multiple people + multiple agents, direct connection of local third-party agents like Claude Code / Codex CLI / OpenClaw, and cloud agents with cloud devices (cloud phones/cloud PCs). The platform narrative fully shifted from "a tool for building bots" to "an agent collaboration workbench."

For learners, this evolution line is itself a product lesson: low-code bot platform → workflow engine → MCP capability supplier → multi-agent collaboration platform, completed in four years, each step landing on an industry paradigm-shift node (very clear when read alongside the brief history).

3. Inferred Technical Architecture ​

The commercial Coze's full architecture is not public, but the open-source coze-studio backend shares lineage with it (officially phrased as "the core engine is fully open"), so combined with official docs a fairly reliable inference is possible:

┌─────────────────────────────────────────────────────────┐
│  Frontend: React + TypeScript                            │
│  ├─ FlowGram workflow canvas engine (open-sourced by     │
│  │  ByteDance)                                           │
│  └─ Bot orchestration / knowledge management / debug pad │
├─────────────────────────────────────────────────────────┤
│  Backend: Golang microservices (Hertz HTTP framework),   │
│  DDD layering                                            │
│  ├─ Agent orchestration service: prompt assembly + skill │
│  │  injection                                            │
│  ├─ Workflow engine: DAG compilation & execution         │
│  │  (Eino runtime)                                       │
│  ├─ Plugin runtime: HTTP call sandbox + auth management  │
│  ├─ Knowledge service: document parsing / segmentation / │
│  │  vectorization / retrieval                            │
│  ├─ Code runner: JS/Python code node sandbox             │
│  └─ Channel adapters: Doubao / Feishu / WeChat / API ... │
├─────────────────────────────────────────────────────────┤
│  Model layer: Doubao family (default) / DeepSeek / Kimi /│
│  custom model APIs (international edition: GPT / Gemini) │
└─────────────────────────────────────────────────────────┘

A few engineering decisions worth learning from:

  • Orchestration logic pushed down into a Go runtime. The open-source edition's official acknowledgments state explicitly: the agent and workflow runtime engines, model abstraction, and knowledge indexing/retrieval come from the Eino framework. In other words, Coze's agent loop is not a Python script but a DAG executor written in a compiled language—a reasonable choice for high-concurrency SaaS, and it explains why workflow execution latency feels good.
  • The prompt assembly pipeline. The "Persona & Reply Logic" users fill in is only raw material; what actually gets sent to the model is the platform-assembled system prompt: persona + skill descriptions (plugins'/workflows' name + description + parameter schema) + memory injection + knowledge-recall snippets + channel-specific constraints. This is the same thing as hand-written agents' context engineering, just productized.
  • The plugin runtime abstraction. Official and custom plugins share one set of OpenAPI description + auth + call sandbox, unifying "tools" as registrable HTTP services. This abstraction was later partially absorbed by the MCP ecosystem (workflows can be published as MCP services).
  • The frontend canvas became a standalone engine. FlowGram is a workflow canvas engine ByteDance open-sourced separately, showing they treat "visual orchestration" as general infrastructure rather than a product detail—a judgment later proven right, as peer platforms (Dify, n8n, Flowise) have been converging their canvas experiences toward it.

Reading the Open-Source Edition Is the Fastest Way to Understand the Commercial One

coze-studio's backend code (Go) is a mirror of the commercial edition's core engine. Want to know "what's the knowledge retrieval's default top-k," "how exactly is the prompt assembled," or "what's the fallback logic for workflow node timeouts"? Reading the source is faster than digging through docs. It's also ready-made material for interview questions like "analyze a mature agent platform" (see the job-seeker knowledge map).

4. Open-Source Moves: coze-studio and coze-loop ​

On July 26, 2025, ByteDance open-sourced two core Coze projects on GitHub (under the coze-dev organization) under the Apache 2.0 license—free commercial use, modifiable, no requirement to open-source derivatives, no additional terms. This is the most permissive licensing posture among Chinese big-tech agent platforms (compared with Dify's custom additional-terms license, it imposes fewer commercial restrictions).

  • Coze Studio (github.com/coze-dev/coze-studio): the open-source edition of the development platform, including agent orchestration, workflows, plugins, knowledge bases, databases, and OpenAPI/Chat SDK. Backend Go + microservices + DDD; frontend React + TS. The deployment bar is deliberately low: 2 cores / 4 GB + Docker Compose gets a service running.
  • Coze Loop (the open-source Coze Loop): an evaluation and ops platform for agents—prompt version management and evaluation, automated testing, trace observability, lifecycle tuning. It corresponds to the engineering problems covered in the Observability and Evaluation chapters; it's the easily overlooked but enterprise-wise most valuable part of the open-source release.
  • Together with the earlier-open-sourced Eino orchestration framework (first half of 2025), three of Coze's four core products are open source; the main one left closed is Coze Space (the general agent product).

Community heat: past 6k stars within two days of open-sourcing, 9.5k in three days; by early August 2025 media reported 19k+, and it has kept growing since (verify the exact current figure on GitHub before citing).

Be clear-eyed about the gap between the open-source edition and the commercial one: the open-source edition is the "engine"; the commercial edition is the "ecosystem." Most official plugins in the plugin marketplace, channel publishing (Doubao/Feishu/WeChat), commercial-grade model quotas, and customer-service/compliance capabilities are not in the open-source edition; official docs also state that some features (like voice customization) are commercial-only. The official README specifically warns: if you deploy the open-source edition to the public internet, you must assess the security risks of account registration, code-node sandbox, SSRF, API privilege escalation, and more yourself. Conclusion: private pilots, secondary-development learning, intranet tools—the open-source edition works; for serving consumer-facing users, you'll most likely need the commercial edition or to fill in the rest yourself.

For teams planning self-hosting or secondary development, a few practical points:

  1. You must connect your own models. The open-source edition ships with no usable models; the first thing after deployment is configuring a model service in the admin backend (OpenAI-compatible protocol or Volcano Engine), or you can't even get into debugging; the knowledge base also needs a separately configured embedding model.
  2. Official plugins aren't freebies. Official plugins in the store involve third-party services' auth keys, which the open-source edition requires you to configure yourself; plugins without keys won't run even when installed.
  3. Read it as a framework; don't use it as a product. The code organization of DDD layering + microservices + the Eino runtime is a rare specimen for learning "how a production-grade agent platform is layered"; but as an out-of-the-box product, its polish and ecosystem completeness fall short of Dify Community—don't be swayed by star counts when selecting.
  4. Run through the security checklist before production: every risk surface the official side itself names (open registration, code-node sandbox escape, SSRF, API privilege escalation) must be covered; for protection approaches see Security.

5. Commercialization and Pricing ​

Coze's commercialization completed three steps from 2024 to 2026: "free acquisition → usage-based billing → subscription plans":

  1. 2024: free Basic edition + pay-per-use Professional (agent calls at 0.002 RMB per call, model tokens billed separately), with Professional users gifted 500 resource points daily.
  2. February 2025: the resource-pack system merged into "Coze resource points," with unified deduction rules.
  3. 2026: resource points renamed "credits," with a full pivot to subscriptions; the old "Professional" edition was retired on May 30, 2026. The Team edition launched June 22, 2026, and the Enterprise edition repriced in July 2026 alongside Coze 3.0.

Subscription tiers as of August 2026 (from official docs; double-check the official site before citing prices):

EditionTierPrice (monthly)Monthly Credits
IndividualFreeRMB 0—
IndividualPlusRMB 39.930K
IndividualAdvancedRMB 9999K
IndividualFlagshipRMB 199199K
IndividualPremiumRMB 999999K
TeamAdvanced/Flagship/PremiumFrom RMB 198 / 398 / 1998From 198K / 398K / 1.998M
EnterpriseStandard/FlagshipFrom RMB 980 / 8980From 345K / 2.07M

Key rules: Individual and Team editions stop working when credits run out; the Enterprise edition converts to a cash balance once credits are exhausted (hybrid billing of subscription + usage). Cloud agents, project collaboration, and custom model connections unlock at Advanced and above; enterprise capabilities like SSO, VPC private links, and custom content-safety policies exist only in Enterprise Flagship.

A Cost Reminder for Engineering Teams

The credit system converts "model calls, video generation, cloud devices, plugin calls" into one pool—simple bills, but fuzzy cost attribution. If your application has a steady model call volume, be sure to estimate "credit unit price vs calling Volcano Engine APIs directly" against your own token consumption—at high call frequencies the platform premium can be substantial, and in that case a hybrid architecture of "Coze as the frontend + self-built agent backend" is often better value (see Cost & Optimization).

6. Positioning vs. Dify / n8n ​

These three tools are often compared together, but their target users and architectural assumptions actually differ greatly:

DimensionCozeDifyn8n
EssenceManaged-SaaS-first agent platformOpen-source-first LLM application platformGeneral workflow automation tool (AI nodes added later)
Target usersNon-technical staff + business teamsDevelopers + technical teamsOps/engineering with automation needs
Core abstractionBot + skills + channel publishingApps (chat/workflow/agent)Nodes + triggers + connections
Model strategyDoubao-first, deep ecosystem bindingModel-neutral, connects to anythingModels are just one of many node types
Channel ecosystemOne-click publishing to Doubao/Feishu/WeChat/DouyinWeak (mainly API/Web)400+ SaaS connectors
Self-hostingcoze-studio (features trimmed)Fully open source, commercial use allowed (additional terms)Fully open source (fair-code license)
LicenseApache 2.0Dify's custom licenseSustainable Use License
Non-AI automationWeakWeakExtremely strong (that's its original job)

Experiential selection conclusions:

  • To quickly validate an AI application's PMF, with target users on domestic channels (WeChat/Feishu/Doubao) and no full-time engineers on the team—pick Coze; there's no real competitor.
  • For self-hosting, model neutrality, and long-term control, with engineering capability on the team—pick Dify; its open-source completeness and community ecosystem remain the best in class. Coze's open-source edition is catching up, but the "engine open, ecosystem closed" pattern won't change soon.
  • When AI is just one link in the flow (say, "email arrives → extract attachments → LLM summarizes → write to CRM → post to Slack"), pick n8n; forcing Coze/Dify is hammering a nail with the wrong hammer.

For a detailed framework and platform comparison, see the selection overview.

7. Who It's For: Paradise for Non-Technical Users, a Boundary for Engineering Teams ​

Coze's real value curve looks roughly like this:

  • 0 → 1 validation phase: unbeatable. An ops colleague builds a customer-service bot with knowledge base and plugins in an afternoon and publishes it to Feishu—no self-built approach moves that fast.
  • 1 → 10 scale-up phase: cracks start to show. Debugging is hard (black-box prompt assembly, limited evaluation tools), version control is weak (workflows lack real Git-style collaboration), and costs rise linearly with call volume.
  • 10 → 100 scale phase: most engineering teams will migrate the core chain to self-built (LangGraph/Eino/in-house), with Coze retreating to the "channel publishing layer + ops tool" position, or being replaced by self-hosted coze-studio + secondary development.

So the career advice for engineers is blunt: knowing Coze is a plus; knowing only Coze is a minus. What recruiters actually want is understanding of the things Coze productized—prompt assembly, RAG pipelines, tool calling, multi-agent routing—and how to implement them in code (see Build an Agent Yourself). Coze is the best "agent concept teaching aid": use it to build intuition fast, then dive into the coze-studio source and write one yourself—that's the complete learning path.

Conversely, there are two scenarios where Coze is more professional than self-building, and reinventing the wheel isn't advised: first, multi-channel distribution (compliance costs of WeChat ecosystem integration are high, and the platform carries that for you); second, content safety—for consumer chat products facing domestic users, compliance filtering is a hard requirement, and the Enterprise edition's content-safety policies are far less hassle than wiring up moderation APIs yourself.

A Pragmatic Getting-Started Path ​

If you're an engineer, approach Coze in this order, with a concrete learning output at each step:

  1. Spend two hours building a bot on coze.cn: persona + one official plugin + one knowledge base, published to Feishu. The goal is building intuition for "what exactly the platform productized."
  2. Rework it in workflow mode: convert free-form conversation into a deterministic "intent recognition → retrieval → generation → validation" flow, and feel the trade-off between autonomy and controllability—the most core lesson in Agent Design Principles.
  3. Deploy the open-source coze-studio locally (2 cores / 4 GB + Docker Compose suffices), read the Go backend source against the official architecture docs, focusing on the workflow engine and prompt assembly.
  4. Hook up Coze Loop, run an evaluation set, and read through the traces—turning observability from concept into feel.
  5. Run a cost projection: take your bot's real call volume and calculate both "Coze credits" and "self-built + direct Volcano Engine API" scenarios, understanding where the platform premium lies and whether it's worth it.

After these five steps, you'll have complete muscle memory for "which components a production-grade agent platform needs"—more useful than ten architecture articles.

References ​