Kimi Agent Cluster in Practice: One Person Commanding 300 AIs to Collaboratively Build a Website

From Chatbots to Agent Clusters: The Evolution of AI Collaboration

Can one person do the work of 300? This question is being redefined in the age of AI Agents. Chinese Bilibili creator Lin Yi recently used the newly launched "Kimi Work Cluster" feature in Kimi's desktop client to have 300 intelligent agents work in parallel for 30 minutes, building a website from scratch that automatically curates trending GitHub open-source projects — called "Open Source Radar." The entire process required nothing more than verbal instructions, with product design, frontend development, backend construction, and data scraping all completed autonomously by AI.

The core capability behind this is the Agent Cluster — getting a large group of AIs to divide labor and collaborate like a human team, completing complex tasks that a single Agent couldn't handle alone. The concept of Agent clusters originates from academic research in distributed computing and Multi-Agent Systems (MAS). As early as the 1980s, AI researchers began exploring how multiple autonomous agents could collaboratively complete tasks, but limited by the natural language understanding capabilities of the time, these systems mostly relied on predefined communication protocols and rigid rules. The emergence of large language models completely changed this landscape — Agents can now communicate in natural language, understand ambiguous instructions, and dynamically adjust strategies, making truly flexible multi-Agent collaboration possible.

Three Mainstream Agent Cluster Architectures Explained

Before diving into the hands-on demonstration, it's worth understanding the current mainstream Agent cluster architectures. Lin Yi outlined three typical patterns in his video:

Pipeline Division of Labor

Similar to a factory assembly line, each Agent handles one stage. For example, when writing an industry report: a research Agent gathers materials first, an analysis Agent extracts insights, and a writing Agent compiles the final document. Each performs their specialized role, producing higher quality at each step, but speed doesn't improve — if the previous step isn't done, the next one has to wait. This pattern corresponds to the Pipeline architecture in software engineering. Its advantage is that each stage can be highly specialized; its disadvantage is that overall latency equals the sum of all stage latencies, and any single stage failure blocks the entire pipeline.

Democratic Free-for-All

Multiple Agents equally express their views on the same topic, questioning, supplementing, and correcting each other. For example, when analyzing whether a stock is worth investing in, multiple Agents debate from market, technical, risk, and policy perspectives, ultimately forming a well-considered conclusion. The academic name for this pattern is "Multi-Agent Debate." Research from Google DeepMind, MIT, and other institutions has shown that multiple large language models debating can significantly reduce individual model hallucinations and reasoning errors, because incorrect viewpoints are more easily exposed and corrected through cross-questioning.

Central Authority Model (Used by Kimi)

One primary Agent first thoroughly understands the requirements, breaks down tasks, then assigns work to specialized sub-Agents. Once everyone finishes, it performs unified review, correction, and delivery. This pattern is the most flexible — the primary Agent can have sub-Agents work in pipeline mode, engage in democratic debate, or even mix multiple collaboration modes.

The Central Authority model has deep theoretical foundations in software engineering, similar to the Orchestrator pattern in microservices architecture. Its counterpart is the Choreography pattern, where services coordinate themselves — corresponding to the Democratic Free-for-All architecture. An important reason Kimi chose the Central Authority model is controllability — the primary Agent acts as a project manager with a global view, capable of dynamically adjusting task allocation based on real-time feedback, which is crucial in complex engineering tasks.

The key advantage: if sub-Agents make mistakes during collaboration, the primary Agent can catch and fix problems during the final review, serving as a safety net.

Hands-On: Building "Open Source Radar" from Scratch

Requirements Breakdown and Task Assignment

Lin Yi gave Kimi very clear requirements: create a website showcasing trending GitHub open-source projects for AI beginners, featuring an attractive UI, ranking lists, search functionality, an AI-curated featured projects section, plus backend database connectivity and automatic scraping of trending GitHub projects.

These requirements would have previously needed at minimum a product manager + frontend developer + backend developer + algorithm engineer. Now, Kimi's primary Agent automatically completed the requirements breakdown: first setting up the directory structure, Git repository, and scaffolding locally, then writing a task distribution document and dispatching 8 sub-Agents to work simultaneously.

Multi-Agent Parallel Development

The division of labor was crystal clear: one backend Agent designed the database, another backend Agent wrote APIs, a frontend Agent built the interface, and an algorithm Agent wrote data scraping scripts. Each sub-Agent was coordinated in an orderly fashion, each working on their own code branch — more disciplined than many junior programmers.

It's worth elaborating on the engineering significance of Git branch management here. Git is currently the world's most mainstream distributed version control system, created by Linux creator Linus Torvalds in 2005. In multi-person collaborative development, each developer works on an independent code Branch, then Merges back to the main branch upon completion, avoiding conflicts from multiple people modifying the same file simultaneously. The fact that Kimi's sub-Agents naturally use branch-based development indicates they've internalized modern software engineering collaboration standards, which is significant for code quality and maintainability.

Once everything was complete, the primary Agent acting as "project manager" merged code, checked for conflicts, connected interfaces, and fixed fields. It actually discovered a code issue in a database module and fixed it independently. Finally, the project ran successfully with just a single deployment command.

Deployment Challenges and Self-Healing

An important requirement of Vibe Coding is being able to share with friends. Lin Yi gave Kimi the server configuration and had it deploy directly to the public internet. Initially, problems arose — SSH connection attempts failed with several different methods.

SSH (Secure Shell) is the standard protocol for remote server management, establishing secure connections between local and remote servers through encrypted channels. The problem encountered this time was quite representative: the @ character in the password causes command-line parsing ambiguity, because in SSH command-line syntax, the @ symbol separates the username from the host address (like user@host). If the password also contains @, the parser gets confused.

But the core advantage of an Agent lies in iterative loops and autonomous research of new approaches. Kimi discovered that the required SSH software wasn't installed, and that the server password contained an @ character that could affect command-line parsing. So it switched strategies entirely, writing a Python script (based on the paramiko library) to handle SSH connections and command execution, fundamentally bypassing the command-line parsing issue. This creative problem-solving ability when encountering obstacles is precisely what distinguishes Agents from simple scripts.

Afterward, it not only successfully transferred code to the server and ran it, but also automatically installed PM2 process manager for subsequent operations. PM2 is the most popular production-grade process management tool in the Node.js ecosystem. Its core value lies in: automatic restart after process crashes, cluster mode support for load balancing, and built-in log management and performance monitoring. Without PM2, if a Node.js application crashes due to an uncaught exception, the service simply goes down. Kimi's automatic installation of PM2 shows it considered production environment stability requirements beyond just completing the deployment.

Later, when a colleague reported that data hadn't updated for two days, Lin Yi had Kimi add a GitHub scraping script to the server with daily automatic execution (via Linux's cron scheduling mechanism), solving the problem effortlessly.

Advanced Cluster Techniques: Beyond Just Writing Code

"Gacha" Mode: Single Pull Becomes Ten-Pull

The most straightforward approach leverages AI output randomness. When large language models generate text, each step samples from a probability distribution, so even with identical prompts, different generations produce varying results — this characteristic is controlled by the "Temperature" parameter; higher temperature means greater randomness and diversity in output. Leveraging this, when having Kimi write articles, you can have it simultaneously output 8 different versions. The primary Agent automatically lists different creative directions like technical, sci-fi, and business, generating them in parallel. Going further, you can have the primary Agent create its own scoring criteria, select the best version from multiple outputs, or even stitch together the best parts of each version into an enhanced composite. This "generate-evaluate-fuse" paradigm essentially trades computational resources for output quality.

Wild Ideas: 108 Heroes Discuss AI

Lin Yi also conducted an interesting experiment: activating 108 Agents to each role-play one of the 108 heroes from the Chinese classic novel "Water Margin," with each Agent projecting AI industry trends for the coming year based on their character's personality and identity. Kimi directly output a 13,000+ word report titled "Acting on Heaven's Behalf, AI for the People." While this experiment seems entertaining, it involves an important AI research direction — Persona-based Generation. By assigning different personality settings to models, you can stimulate more diverse perspectives and richer creative output, which has practical application value in creative writing, product brainstorming, risk assessment, and other scenarios.

Practical Tips: Three Tricks to Maximize Kimi Cluster Performance

Tip One: Proactively trigger cluster mode. Add a line to your prompt like "You must enable the Agent cluster feature, using 8 to 10 sub-Agents to complete the task in parallel." This noticeably increases the probability of cluster activation and concurrency count. This is actually a common technique in Prompt Engineering — using explicit instructions to guide the model into a specific working mode rather than relying on the model to judge whether clustering is needed.

Tip Two: Make good use of the Web Bridge plugin. Traditional web data retrieval works through direct API requests, but many websites block non-browser requests through CAPTCHAs, login state detection, anti-scraping mechanisms, and other measures. Web Bridge's approach is to directly control the user's real Chrome browser instance, based on Chrome DevTools Protocol (CDP) technology. This way, all requests carry the user's cookies, login state, and installed browser extensions (like ad blockers, translation tools, etc.). From the website server's perspective, this is indistinguishable from manual user browsing. However, it currently only supports Chrome; other Chromium-based browsers (like Edge, Brave, etc.) may have compatibility issues.

Tip Three: Access professional databases for free. Kimi Work's plugin functionality connects to everyday tools like Feishu, DingTalk, and WPS, but also provides free access to professional database APIs that normally require paid subscriptions — such as Tonghuashun iFinD financial database and Tianyancha enterprise data. Tonghuashun iFinD is a leading product in China's financial data space, alongside Wind as standard data terminals for brokerages, funds, banks, and other financial institutions. It covers all categories of financial data including A-shares, Hong Kong stocks, US stocks, bonds, funds, and macroeconomic data, plus professional features like quantitative backtesting and financial modeling — normally costing over 1 million RMB per year. Kimi Work's free access to these data interfaces through plugins means individual users and small teams can obtain institutional-grade data support, which has significant implications for financial technology democratization.

Industry Trends: Multi-Agent Collaboration Becomes an AI Development Priority

Current experiments with multi-Agent systems are extremely dense. Claude Code is Anthropic's command-line AI programming tool, whose SubAgent mode allows the primary Agent to delegate subtasks to independent Claude instances for parallel processing. OpenAI's Codex is similarly exploring multi-Agent collaboration paths. The Vibe Coding plugin OMI Open Agent goes even further with a Team Mode — the primary Agent can create independent working groups based on task difficulty, where members can divide labor in parallel, share task lists, and even have "mailboxes" for sending messages to each other, attempting to simulate real team communication and collaboration patterns.

The rapid release of these products indicates that the industry has reached consensus: single-Agent capability ceilings are approaching, and multi-Agent collaboration is the key path to breaking through bottlenecks. From an academic perspective, Stanford University's 2023 "Generative Agents" paper first demonstrated the possibility of 25 AI Agents autonomously living, socializing, and collaborating in a virtual town, and is considered a milestone in multi-Agent research. These academic explorations are now rapidly transforming into commercial products. How to make large models perform more effectively in Agent workflows will certainly be a key direction in AI development.

Final Thoughts: One-Person Army Is Becoming Reality

Kimi Agent clusters can't truly replace 300 professional employees, but many tasks that previously required multi-person collaboration and phased execution can now be autonomously broken down, processed in parallel, and automatically consolidated by a group of Agents.

For development beginners, the greatest significance lies in crossing the "zero to one" threshold. The generated demo certainly won't be perfect, but you can directly adjust styles, add features, and learn to understand the entire project through continuous optimization. This "get it running first, then iterate" learning path forms a stark contrast with the traditional "learn theory first, then practice" approach, and aligns perfectly with Silicon Valley's "Minimum Viable Product" (MVP) philosophy. The value of Agent clusters isn't just about making professional teams more efficient — ordinary people can now independently realize small products that previously required multi-person collaboration. "One-person army" is transforming from a joke into reality.