AgentKit Samples: Runnable Python Examples for the Volcengine AgentKit Platform

What AgentKit Samples Provides and Who Needs It

AgentKit Samples is a collection of runnable Python programs for the Volcengine AgentKit platform, the enterprise AI agent development product from ByteDance. The repository is not a library or a framework; it is a collection of working code showing how to build agents on top of the AgentKit runtime. It targets two groups: developers who are new to the platform and need a working starting point, and engineers with some experience who want a model for more complex patterns such as multi-agent orchestration, RAG, or real-time voice.

The samples cover the full range of complexity available on the platform. The simplest example, hello_world, shows how to create a basic conversational agent with short-term memory. The most complex examples, such as the hybrid cloud enterprise customer service agent, demonstrate how to combine knowledge bases, persistent memory, tool calling, multi-agent coordination, and observability in a single deployment. Between those two points are fifteen additional examples covering practical use cases: restaurant ordering workflows, AI-assisted coding, video generation, store inspection, data analysis, and e-commerce video creation.

The platform itself is described in the repository as providing standardised development tooling and cloud-native infrastructure for building and deploying intelligent agents. The samples are the practical counterpart to the platform's API documentation.

Repository Layout: Tutorials, Use Cases, and Integrations

The repository is divided into three directories under python/. The first, python/01-tutorials/, contains beginner-level examples organised by AgentKit subsystem: runtime basics, tools, memory, knowledge, and framework integrations. These are intended to teach one concept at a time and are the right entry point for developers new to the platform.

The second directory, python/02-use-cases/, holds more complete applications. Unlike the tutorials, each use case combines several platform features to solve a practical problem. The restaurant ordering assistant, for example, exercises complex business flow logic, asynchronous tool calls, context management, and custom plugins together in one agent. The store inspection assistant demonstrates multi-agent coordination across several specialist sub-agents. These examples are closer to production patterns than to teaching material.

The third directory, python/03-integrations/, covers migration from other agent frameworks. The README states that AgentKit Runtime natively supports LangChain, LangGraph, Strands, Google ADK, and projects built on Bedrock AgentCore Runtime. Developers with existing code in those frameworks can use the migration tooling to generate an AgentKit Runtime entry point without rewriting their core business logic.

The repository also includes a go/ directory for Go-language work, a skills/ directory, and a workflow_utils/ directory, though the bulk of the documented samples are in Python.

Setting Up Dependencies and Running the First Example

The repository requires Python 3.10 or later. Two packages from PyPI must be installed: veadk-python, which provides the runtime for executing agents, and agentkit-sdk-python, which provides the interface to the AgentKit platform. Docker is listed as optional, for local container builds.

Once the packages are installed and Volcengine credentials are configured, the hello_world tutorial is the first practical step. It lives at:

cd python/01-tutorials/01-agentkit-runtime/hello_world

The README describes it as an entry-level conversational agent that demonstrates how to create an agent with short-term memory. Each sample directory is documented as containing a complete implementation with an explanation of how the components fit together.

For developers who already have an agent project in LangChain, LangGraph, Strands, or Google ADK, the migration command generates an AgentKit Runtime entry point automatically:

agentkit migrate

The README states this converts an existing project into a deployable veadk project. For Python applications with a non-standard structure, and for low-code workflow projects, the README describes a combined approach using the migration command and the AgentKit Codex Sandbox to automate the conversion. The migration examples live at python/03-integrations/migration.

There are no GitHub releases for the repository; the main branch is the only published version, and there is no version-pinning mechanism in the sample code itself.

Multi-Agent Patterns: Hierarchies, A2A, and Runtime Callbacks

Several samples deal specifically with coordination between more than one agent. The multi_agents example shows how to use a hierarchical structure and specialised roles to distribute a complex task across agents. The README describes this as demonstrating how to achieve intelligent handling of complex tasks through a layered structure and professional division of labour.

A separate pattern, a2a_simple, shows distributed multi-agent communication using the A2A protocol, where agents talk to each other rather than being orchestrated by a central supervisor. The difference between these two patterns is architectural: the hierarchical approach has a coordinator agent that delegates to workers, while A2A uses peer-to-peer messaging. Both patterns are implemented in separate tutorials so developers can compare the two approaches against their own deployment constraints.

The agent_callbacks example documents the runtime lifecycle hooks available in the AgentKit runtime. It covers callback functions for each phase of the agent lifecycle, along with guardrail features. This is relevant for teams that need to add monitoring, logging, or safety checks at specific points in agent execution without modifying the agent's core logic.

For real-time use cases, the realtime_voice example shows how to build a voice chat assistant. It includes both a Python server component and a web client for user interaction, which makes it one of the more involved tutorials in the repository.

Volcengine Service Dependencies: The Platform Lock-in Constraint

The samples that go beyond basic conversation all depend on specific Volcengine services. The RAG example, vikingdb_agent, requires VikingDB, Volcengine's vector database product. The MCP integration example connects to TOS, ByteDance's Tencent Object Storage equivalent on the Volcengine cloud. The memory management example, vikingmem_agent, also uses VikingDB for persistent storage.

This is not a fault in the repository; the samples are doing exactly what a platform sample repository is supposed to do. But it means that evaluating whether the samples are useful requires first evaluating whether Volcengine infrastructure is on the table. A team running on AWS or Google Cloud would need to replace the storage and retrieval backends in every use case that uses them, which is not a small change.

The documentation is another practical constraint. The README is written entirely in Chinese. Section headings, sample descriptions, the project structure overview, the prerequisites table, and the contributing section are all Chinese text. Commands and package names remain in their original English form, so a developer can follow the structure, but understanding the context around each example requires reading Chinese or using a translation tool. There is no English-language documentation linked from the repository.

AgentKit Samples vs. Google ADK Samples

Google ADK (Agent Development Kit) is Google's framework for building AI agents, distributed with its own sample repository and targeting Google Cloud infrastructure. Both repositories serve the same purpose: they give developers working, runnable code for a specific agent platform. The difference is the cloud they assume.

Google ADK samples target Google Cloud services and use Gemini models as the default backend. AgentKit samples target Volcengine services and use whatever model the platform provides. A developer choosing between the two is primarily choosing between ByteDance's cloud and Google's cloud, not between different agent architectural philosophies.

The practical difference is where the compute, storage, and model access come from. Neither repository is a general-purpose agent framework that can run on any infrastructure; both are sample code for platform-specific runtimes. A developer who needs infrastructure-agnostic examples would be better served by a framework like LangGraph or CrewAI, both of which have their own example collections and are not tied to a single cloud provider.

Editorial conclusion

AgentKit Samples is the right starting point for Python developers who are already committed to the Volcengine platform and need working, graded examples to copy from. Developers evaluating whether to adopt Volcengine as their agent infrastructure should read through the samples before committing: the mix of Volcengine-specific services (VikingDB for vector retrieval, TOS for object storage) throughout the use cases makes partial adoption awkward. Developers building on other clouds should look elsewhere, as the samples assume Volcengine credentials throughout and the documentation is written in Chinese.

Frequently asked questions

Official sources

1. Official README
2. Project repository