The Models Are Strong, But It's Not Just the Models That Are Strong | How Volcano Engine Is Closing the Loop on Agent Development

**

When Agents Enter Real Business.

👦🏻 Author: Jingshan

🥷 Editor: Koji

🧑‍🎨 Layout: NCon

This past year, everyone's been talking about large language models. Whether on WeChat Moments or in tech group chats, the conversation always circles back to "which domestic or foreign model just broke through" or "which benchmark just got topped."

But when it comes to actual day-to-day work, many people feel a real tension: the models are genuinely powerful, but actually integrating them into business operations as a usable Agent? That's still pretty tricky.

How do you configure the environment? How do you tune the prompts? How do you connect business data?

These granular details remain real barriers.

With these very concrete questions in mind, the Crossing team attended the 2025 Volcano Engine Winter Force Conference Developer Forum, where the entire agenda revolved around "Agent."

December 18 was day one of Force Conference, and two headlines dominated that day:

【1】Doubao multimodal large model 1.8 officially released;

【2】Doubao large model daily usage exceeded 50 trillion tokens.

The "Developer Main Forum" on December 19, compared to the previous day's flurry of numbers, featured a toolkit that many found familiar: Volcano Ark, AgentKit, Coze Programming, and TRAE CN Enterprise Edition.

In fact, many people likely recognized these names from previous coverage.

We've discussed Coze's low-code capabilities in prior articles, and shared our experience with TRAE for programming.

🚥

At this Force Conference, this Agent development workflow has evolved into a complete Agent development matrix.

From underlying model services to middleware platforms to top-layer development tools, Volcano Engine has assembled a more complete puzzle for Agent development.

We want to walk through our specific observations, impressions, and the upgrades to these Agent matrix tools across several dimensions.

Why Do We Need an "Agent Matrix"?

We've been saying that in 2025, AI is at the stage where "the wind rises from the tips of the green duckweed."

What this means is that truly important changes often emerge quietly from the details. Over the past two years, we've been more easily drawn to the "visible metrics" — parameter scales, leaderboard rankings.

But when AI, and particularly AI Agents, actually enters specific scenarios and gets put to use, the process反而 feels somewhat quiet.

And it's precisely at this stage that a new shift is becoming clear: the "hand-rolled" approach to building Agents is increasingly cost-ineffective.

So before diving into specific tools, I want to step back and talk about the Agent development workflow many people are currently grappling with, and "what kind of Agent do we actually need?"

This past year, many people's understanding of Agents still stopped at "write a good prompt." But anyone who's actually shipped a production project knows: the gap between a demo and an enterprise-grade Agent is vast.

A mature Agent workflow is more complex than we imagine:

You need underlying model support (not just conversation, but context and multimodality), middleware orchestration logic (knowing when to query databases, when to call APIs), memory mechanisms (remembering user history), and a robust evaluation and monitoring system (what happens when it hallucinates?).

It's genuinely complex.

So relying on any single tool makes it difficult to cover the full chain.

An IDE alone means hand-rolling everything — too inefficient. A low-code platform alone gets stuck when facing complex custom business logic. Model APIs alone are too far from actual business scenarios.

This is why at the Force Conference venue, many people had an immediate reaction upon seeing this "Agent development matrix": these problems have been systematically decomposed.

It breaks down roughly into three layers:

【1】Foundation Layer (Volcano Ark)

This layer solves the most fundamental problems.

You don't need to train models yourself. Volcano Ark wraps large models as services (MaaS), providing core inference, fine-tuning, and context capabilities.

【2】Platform Layer (AgentKit)

This layer solves the "assembly" problem.

AgentKit targets more complex, serious business scenarios, emphasizing controllable workflow orchestration. Its goal is clear: minimize reinventing the wheel, and focus energy on the business itself.

【3】Tool Layer (TRAE & Coze)

This layer solves the "hand-rolled" problem.

When standard components fall short, an AI IDE can help tackle personalized core code. Coze leans toward rapid experimentation and validation — getting ideas running quickly.

Viewed together, these three layers send a clear signal:

Agent development has moved from scattered tools to a full-chain solution spanning models, platforms, and engineering.

With this "panoramic perspective," let's look at each component in this matrix — what directions they're innovating toward, and what problems each is solving.

Below, we've compiled 5 particularly noteworthy highlights.

1) Coze Development Platform's Major Upgrade

The Coze development platform has been officially rebranded as Coze Programming, with the official positioning: one-stop cloud-native Vibe Coding development platform.

If you're a product manager or operator who understands the business, or even just an ordinary person with clear needs and good ideas, the first question you face isn't really about feature design.

It's whether you need to learn Python, whether to wrestle with local environments, whether servers and deployment require their own crash course.

At Force Conference, Coze Programming's answer was: you still need to, but much less than before.

The subtext: coding ability still matters, but it's no longer the sole ticket to participate in development.

This is the new experience Coze Programming and Vibe Coding will bring.

Vibe Coding shifts the starting point of the entire development flow forward. Previously, development began with environment configuration, proceeding through coding, debugging, deployment, and operations.

Now the starting point becomes expressing requirements. Users can directly build intelligent agents (Vibe Agent), workflows (Vibe WorkFlow), and websites through natural language conversation.

One key thing Coze Programming does is shorten the lengthy, energy-consuming, most-discouraging-for-non-technical-users chain between "writing code" and "making code run."

Installing software and configuring environments can be de-prioritized; opening a browser may be your complete development environment.

Now, the "Coze Programming" platform is more friendly to "people who can articulate requirements but don't want to pay massive learning costs for deployment and operations," as well as "those who want to quickly validate an idea rather than building out a full technical stack from day one." And Vibe Infra is also a key focus of this Coze Programming update — the AI Agent platform now has infrastructure capabilities for automated management, deployment, and execution.

2) TRAE CN Enterprise Edition Released

TRAE is ByteDance's flagship AI IDE product.

For quite some time, it has attracted substantial user adoption.

The conference revealed several figures: 92% of ByteDance's engineers use TRAE internally, individual registered users have surpassed 6 million, and TRAE has been deployed in real scenarios within ByteDance.

For example, on the Douyin local lifestyle team, TRAE's AI code contribution rate exceeds 43%.

For developers, AI IDE productivity gains are obvious. The market has plenty of competing products.

Think back to how we used to code: most time was spent fixing bugs, writing unit tests, checking documentation.

So for individual developers, TRAE's efficiency boost is highly valued. But for enterprises, the biggest concern about adopting AI IDEs is: determinism.

Is AI-generated code secure? Can it run directly? Will it introduce new vulnerabilities?

This is why many at the venue paid particular attention to TRAE CN Enterprise Edition.

This TRAE CN Enterprise Edition release attempts some innovations on these fronts, mainly targeting enterprise scenarios.

Addressing four major enterprise challenges — performance requirements, deployment adaptation, productivity tracking, and code security — TRAE CN Enterprise Edition delivers comprehensive optimization: enterprise-grade large-repository performance, high-concurrency and long-context-window support; full-scenario business adaptation from knowledge bases to Agents.

It supports real-time productivity tracking and management, plus full-chain encrypted code transmission. Zero cloud storage, ensuring enterprise security compliance.

On the enterprise front, the conference also offered some substantively "weighty" new figures to illustrate what scale TRAE CN Enterprise Edition is designed for.

For instance, in terms of code and asset scale, it already supports 100,000-level files and 150-million-line code ultra-large repository indexing — essentially targeting real enterprise-grade codebases.

For many teams with long histories and accumulated code layers, the AI IDE can now work within the overall code context. On the compute side, TRAE CN Enterprise Edition directly connects to enterprise GPU clusters while compressing interaction latency to millisecond-level response — which is actually critical.

Because once you enter real development workflows, if the AI "takes a moment to get back to you," the experience rapidly deteriorates. Only millisecond-level feedback can truly embed into daily coding rhythms.

Its support for ultra-long context windows is fundamentally about adapting to complex engineering scenarios.

Real-world enterprise programming is rarely a single-file, single-module problem. The context needs to stretch long enough for AI to potentially understand "why it was written this way back then."

From these numbers, you can see TRAE CN Enterprise Edition is trying to push AI to a level that can genuinely bear enterprise complexity.

3) AgentKit: Build a Cloud Agent in 8 Minutes

AgentKit can be understood as a complete toolkit Volcano Engine prepared for enterprises, trying to transform Agent building from "hard to land" to "directly actionable."

Many people currently building AI Agents share similar experiences: the demo runs great, results look good, but the moment you actually need to connect to business systems, data, and permissions, things get "panic-inducing."

AgentKit attempts to bridge the gap between demo and production.

In positioning, AgentKit functions more like an enterprise-grade Agent foundation.

It doesn't focus on any single model or prompt segment, but tries to cover the entire chain from Agent development, deployment, and execution to operations and optimization.

Specifically, to achieve this, AgentKit has 8 core modules as support: starting from identity and access management Identity, runtime Runtime, cloud sandbox Sandbox, gateway Gateway, memory bank Memory, observability Observability, evaluation Valuation, to safety guardrails Guardrails.

This extensive module capability collectively forms an Agent that actually works in enterprise settings.

In other words, it's answering more practical questions: will this Agent cause problems after going live? If something happens, can we trace it? Can we contain the impact?

At the conference, a very vivid example was given: building an AI Agent capable of image and video generation from scratch in 8 minutes, and deploying it to the cloud.

This live demonstration showcased the capabilities and completeness of Volcano Engine's AgentKit in real-world scenarios.

4) Volcano Ark Empowering Enterprise Agent Construction

If TRAE CN Enterprise Edition, Coze Programming, and AgentKit are about directly building products, then Volcano Ark is the foundation supporting them all.

Volcano Ark is already quite familiar to us.

At this conference, our previous understanding of Volcano Ark as a MaaS (Model-as-a-Service) platform — basically renting GPUs, calling APIs — was expanded. This time Ark demonstrated a logic centered on: the full lifecycle of an Agent. It attempts to solve three fairly fundamental problems: how to build fast? How to get smarter? How to remember?

Anyone who's developed complex Agents knows that manually managing context and tool calls is genuinely difficult and tedious.

Volcano Ark's Responses API essentially "standardizes" these troublesome tasks.

It comes with built-in context management, supporting chained multi-turn conversation processing, and seamlessly handling both text and mixed text-image content.

Real cases were presented on stage. Gaotu Techedu uses it for problem search and study companionship; Qixin uses it for product compliance checking. Cost reductions are dramatic, with some scenarios dropping by as much as 80%.

To help developers better complete tool calls, Volcano Ark Experience Center launched "Developer Mode," which turns every request and every parallel tool call into visual nodes. This "debug APIs like an IDE" experience is relatively developer-friendly.

Second, there's now consensus: pre-training only gets the model through step one; to perform well in specific business contexts, you need reinforcement learning (RL).

But RL's barrier is too high.

Volcano Ark launched a Serverless RL platform, essentially turning reinforcement learning into a serverless service. Enterprises don't need to build complex training clusters themselves, nor manage simulation environment acceleration — just focus on business data.

Finally, a capable Agent needs database support. Volcano Viking was also a major focus of this conference:

VikingDB vector database upgraded with progressive information retrieval: combining large model ranking algorithms for finer judgment and sorting of recalled results, achieving "find all" relevant results first, then select "precisely right" results.

Meanwhile, Volcano Viking memory bank received further upgrades: not just remembering text, but also capturing visuals.

Plus it fused memory bank and knowledge base, so Agents can remember not just "what's written in the materials," but also "what tasks the user has done before."

From tools to innovation, Volcano Ark as foundation is making Agents "a little smarter, a little more business-savvy."

5) Developer Community

Finally, I want to talk about something beyond the technology — after all, tools still need people to use them.

After this Force Conference, the former "Volcano Engine Developer Community website" has been upgraded to "Agent Developer Community," which will provide more complete knowledge structures and learning paths around Agents.

Website: https://developer.volcengine.com/

Meanwhile, a new module called "Hands-on Lab" launched — essentially a directly accessible cloud sandbox environment.

In this lab, the platform provides free experimental cloud resources. You can directly call Doubao large models, AgentKit, and other core tools, following tutorials to build a real Agent application from scratch.

TRAE and Coze scenarios will be added progressively going forward.

Beyond tools and learning resources, the conference also officially released a new Agent Core Developer Program, with many active evangelists and technical experts joining.

On the offline front, I also saw a new organization formally unveiled at the venue: ADG (Agent Developer Group). This is a city-based developer community initiative launched by Volcano Engine, currently live in Beijing, Shanghai, Shenzhen, and Chengdu, with plans to expand to Guangzhou, Hangzhou, Wuhan, and other cities next year to help local developers learn about Agents together.

This matters quite a bit for developers. With AI technology iterating so rapidly, going it alone easily leads to getting lost.

The ability to connect with others matters in the AI era.

---

2025 is being called the Year of AI Agent, at the stage where "the wind rises from the tips of the green duckweed."

It often manifests through very concrete, pragmatic, genuinely deployable details. People are starting to focus more on Agent workflows in real scenarios.

Agent development is thus moving toward a more complete, more reusable system.

When the boundaries between models, platforms, and tools become easier to bridge, and developers no longer need to expend energy repeatedly on foundational problems, AI Agents have a chance to become part of "real business."

This shift won't necessarily deliver "super dazzling" effects immediately, but it will continuously lower the barrier to entry for developers.

AI won't eliminate developers. It will reward those who wield tools well and remain endlessly curious about the world.