Manus vs Google Deep Research vs Flowith: A Hands-On Comparison of AI Agents for Courseware Generation

Introduction

With the explosive growth of AI agent products, more and more tools now possess the ability to "autonomously research + generate content." AI agents differ from traditional chatbots in that they have the capability for autonomous planning, tool invocation, and multi-step execution. The concept of AI agents originates from the BDI (Belief-Desire-Intention) model in artificial intelligence, emphasizing autonomy, reactivity, and sociality. Unlike traditional chatbots based on a single-turn or multi-turn "input-output" dialogue model, AI agents introduce the ReAct (Reasoning + Acting) paradigm—where the model first reasons at each step, then decides on the next action, forming an observe-think-act loop.

A typical AI agent architecture contains four core modules: the Planner is responsible for breaking complex tasks into executable sub-steps; the Tool Use layer handles calling external tools such as search engines, code executors, and file generators; the Memory module maintains context consistency throughout multi-step execution; and the Output layer integrates results into the format the user needs. The implementation of the Tool Use layer varies—OpenAI's Function Calling, Anthropic's Tool Use, and Google's Gemini Function Calling are all current mainstream technical approaches. The Memory module is typically divided into short-term memory (the context window of the current session) and long-term memory (historical information persisted through vector databases), and their coordination determines the agent's consistency in long task chains. It is precisely these implementation differences that determine the performance gap between different AI agents when facing the same task.

This article is based on a hands-on test video by a Bilibili creator, comparing three popular AI agent products—Manus, Google Deep Research, and Flowith—using the same prompt to complete the task of "generating Kafka teaching courseware and speaker notes," to see who is the true productivity champion.

Test Design: Same Prompt, Fair Competition Among Three AI Agents

To ensure a fair comparison, the tester used the exact same prompt for all three products:

Please help me produce a tutorial on Kafka's core principles and practical applications, and output the following:

1. Create an elegant teaching courseware in HTML, covering Kafka's core principles and practical applications;
2. Produce a speaker script, output in plain text format.

Why Kafka Was Chosen as the Test Subject

Apache Kafka is a distributed event streaming platform originally developed by LinkedIn and later donated to the Apache Software Foundation. Its core design philosophy is high-throughput, low-latency messaging, widely used in real-time data pipelines, stream processing, and event-driven architectures. Kafka employs a publish-subscribe model, achieving efficient message distribution through core concepts like Topics, Partitions, Brokers, and Consumer Groups.

Kafka is an ideal test subject also because of the depth of its technical ecosystem. Beyond its core message queue functionality, the Kafka ecosystem includes Kafka Streams (a stream processing library), Kafka Connect (a data integration framework), Schema Registry (data format management), and ksqlDB (a streaming SQL engine). Its underlying storage mechanism is based on Partitioned Logs, using sequential writes and Zero-Copy technology to achieve extremely high I/O performance, with a single cluster capable of supporting throughput of millions of messages per second. Understanding these concepts requires crossing multiple knowledge domains including distributed systems, operating systems, and network protocols, which places high demands on the breadth and depth of an AI agent's knowledge coverage.

In today's era of big data and microservice architectures, Kafka has become a standard component of enterprise-grade data infrastructure, used at scale by companies like Netflix, Uber, and LinkedIn. Because Kafka's technical system is vast and concept-rich, it makes an ideal topic for testing AI agents' content generation capabilities—requiring both accurate understanding of technical principles and clear, structured expression.

Task Breakdown

This task is actually not simple. It requires the AI agent to complete the following steps:

• Information research: Search the internet for Kafka-related technical materials
• Content organization: Extract core principles and practical applications
• Formatted output: Generate structured HTML courseware
• Secondary creation: Write accompanying speaker notes based on the courseware

This is a typical Compound Task—requiring the AI to complete multiple interrelated sub-tasks in a single interaction, with dependencies between sub-tasks. Unlike simple Q&A, compound tasks require the AI to have task decomposition ability (breaking large tasks into smaller steps), context passing ability (output from the previous step serves as input for the next), and multi-format output ability (generating HTML, plain text, and other formats simultaneously). These tasks are difficult because a failure at any stage cascades to affect the quality of subsequent steps, thoroughly testing the AI agent's planning and execution quality.

Manus Test Results: Adequate but Unremarkable

As a recently viral AI agent product, Manus's performance in this test can be described as "passing grade."

From the replay function, we can see that Manus's workflow is fairly clear: first researching Kafka technical documentation on domestic websites, looking at core principles first, then practical applications, with data sources mainly from domestic blog sites. It then generates an HTML-format teaching courseware, and finally generates speaker notes based on the courseware.

Manus Courseware Quality Assessment

The teaching courseware generated by Manus is entirely text-based, with no visual elements whatsoever. As teaching courseware, this purely textual presentation is not user-friendly—too much text, lacking chunking and visual hierarchy.

Having AI generate directly usable HTML teaching courseware actually involves two dimensions of capability: content organization and front-end presentation. At the content organization level, the AI needs to layer technical knowledge according to pedagogical logic—from concept introduction to principle explanation to practical cases, forming a progressive knowledge structure. At the front-end presentation level, the AI needs to generate semantically correct HTML tags, reasonable CSS styles, and responsive layouts to ensure the courseware renders properly in browsers with good visual results.

From a technical perspective, having AI generate high-quality HTML teaching courseware is essentially a cross-modal generation problem. The model needs to handle three layers of tasks simultaneously: the semantic layer (correct use of HTML5 semantic tags like <section>, <article>, <figure>), the style layer (CSS Flexbox or Grid layouts, responsive media queries, typographic vertical rhythm), and the interaction layer (possible JavaScript animations or navigation logic). Current mainstream large language models perform excellently on code generation benchmarks (like HumanEval, MBPP), but these tests primarily evaluate logical correctness, not visual aesthetics. Template-based solutions using professional presentation frameworks like reveal.js and Slidev can partially solve this problem, but require the AI agent to have toolchain support for calling these frameworks. Manus achieved basic coverage in content organization but was clearly insufficient in front-end presentation, resulting in courseware that is content-complete but visually underwhelming.

Manus Speaker Notes Quality Assessment

The speaker notes basically follow the courseware structure and represent a fairly complete output. Overall, Manus completed the task, but the output has no highlights—it's at a "usable but not impressive" level.

Google Deep Research Test Results: Task Incomplete, Output Format Chaotic

As Google's deep research tool, Google Deep Research performed surprisingly poorly in this test.

Seemingly Reasonable Process Planning

Deep Research's planned workflow appears reasonable: search materials → organize materials → generate HTML courseware → generate speaker notes from HTML. However, actual execution severely deviated from the plan.

Three Fatal Problems

1. Chaotic HTML output format: Although the output contained some HTML tags, the overall format was messy and completely unusable as normal teaching courseware.
2. Missing speaker notes: Deep Research completely omitted the speaker notes output—the task was not completed. This perfectly illustrates the cascade effect of compound tasks—when the HTML generation step encounters problems, the subsequent speaker notes generation that depends on it also fails.
3. Data source bias: All collected materials came from international websites. While the search scope was broad, the applicability of these English materials for a Chinese teaching scenario is questionable.

In summary, Google Deep Research failed to complete the task with poor output quality in this test, ranking last. This also demonstrates that Deep Research is better suited for deep research report-type tasks rather than compound tasks requiring formatted output. Google Deep Research's core advantage lies in its powerful search and information synthesis capabilities—it can extract key information from massive web pages and generate structured research reports, but when tasks require crossing from "understanding content" to "beautiful presentation," its toolchain support is clearly insufficient.

Flowith Test Results: Best Output, Clear Courseware Structure

Flowith is a relatively low-profile AI agent product that the tester originally discovered as an alternative when Manus went viral. But in this comparison, its performance was actually the most impressive.

Flowith's Workflow

Flowith's execution logic is very clear:

1. Search for Kafka core principles-related materials
2. Search for Kafka practical applications-related materials
3. Analyze and organize, generate HTML-format courseware
4. Generate speaker notes based on the courseware

Data sources include authoritative international websites like the official Kafka site, with very detailed collected materials. Notably, Flowith adopted a combined domestic and international approach to data collection—obtaining first-hand authoritative materials like the Apache Kafka official documentation to ensure technical accuracy, while also referencing Chinese content from domestic tech communities to ensure localized expression.

The differences among the three products in the data collection phase fundamentally reflect their different Retrieval-Augmented Generation (RAG) strategies. The core idea of RAG is to retrieve relevant documents before generation, injecting retrieved content as context into the prompt, thereby reducing model hallucination and improving factual accuracy. The RAG process typically includes four steps: Query Rewriting, Document Retrieval, Re-ranking, and Context Compression. Differences among products in query rewriting strategies (whether to split the original question into multiple sub-queries), search engine selection (Google, Bing, or specialized APIs), and how retrieval results are merged directly lead to differentiation in final content quality. Flowith's balanced strategy significantly improved the quality and applicability of its final output.

Flowith Courseware Quality Assessment

The teaching courseware generated by Flowith is the most well-structured among the three products. Each knowledge point and feature is chunked, with clear structural hierarchy—an ideal output for teaching courseware.

However, there are some minor issues: the layout is slightly messy in places. The tester noted that if a model more specialized in writing front-end code were used to generate the HTML, the results would likely be better. Current large language models have made significant progress in code generation, but combining content understanding with front-end aesthetics remains a challenge—models can generate syntactically correct HTML and CSS, but their judgment on visual design aesthetics, fine-tuning of spacing proportions, and color coordination still depends on patterns in training data, lacking true design intuition.

Flowith Speaker Notes Quality Assessment

The speaker notes are also well-chunked, with complete content that corresponds well to the courseware structure.

Comprehensive Comparison of Three AI Agents

Evaluation Dimension	Manus	Google Deep Research	Flowith
Task Completion	✅ Complete	❌ Incomplete (missing speaker notes)	✅ Complete
Courseware Quality	Medium (text only)	Poor (chaotic format)	Good (clear chunking)
Speaker Notes Quality	Medium	Missing	Good
Data Sources	Domestic blogs	International sites (broad scope)	Combined domestic & international
Process Transparency	Has replay	No replay	Has detailed steps
Overall Ranking	🥈 Second place	🥉 Third place	🥇 First place

The Deeper Impact of Data Source Strategy

When AI agents execute research tasks, the choice of data sources directly affects the quality and applicability of the final output. In this test, Manus primarily collected content from domestic blogs—advantageous for matching Chinese users' expression habits and use cases, but blog quality varies widely and may introduce inaccurate information. Google Deep Research primarily collected from international websites—while able to access authoritative first-hand materials like official Kafka documentation, English materials require additional translation and localization for Chinese teaching scenarios. Flowith's comprehensive collection of both domestic and international materials balanced both authoritativeness and localization. This difference reflects different products' design orientations in search strategy and information fusion capabilities, and reminds users to consider the target audience's language and cultural background when choosing tools.

Three Key Findings

First, brand recognition ≠ actual capability. Google Deep Research and Manus have far higher recognition than Flowith, but on this specific task, the low-profile Flowith performed best. When choosing an AI agent, you can't just look at brand prestige.

Second, compound tasks are the litmus test for AI agents. For simple Q&A or search, most AI can handle it. But when tasks involve multi-step planning and multi-format output, the gaps between products get amplified. Compound tasks require the AI agent's Planner, Tool Use layer, Memory module, and Output layer to work in coordination—any module's weakness becomes a bottleneck for overall performance.

This article's testing methodology, while intuitive and effective, raises an industry-wide question: how do we systematically evaluate AI agent capabilities? Currently, academia and industry have proposed multiple evaluation benchmarks—GAIA (General AI Assistants) evaluates agent performance on real-world tasks, WebArena evaluates agent operation capability in web environments, and SWE-bench evaluates agents' ability to solve real software engineering problems. These benchmarks typically score across four dimensions: task completion rate, step efficiency, output quality, and robustness. However, for compound content generation tasks (like the courseware + speaker notes scenario in this article), there is currently no standardized evaluation framework—an area urgently needing improvement in the AI agent field.

Third, formatted output remains a weakness for AI agents. Even the best-performing Flowith had shortcomings in HTML layout. This tells us that current AI agents are already good at "content understanding" but still have room for improvement in "beautiful presentation." In the future, as multimodal models develop and fine-tuning techniques specifically targeting front-end generation mature, this weakness is expected to be gradually addressed.

Final Thoughts: Don't Follow Hype Blindly When Choosing AI Tools

This hands-on test gives us an important insight: There's no universal AI tool—only the tool best suited for a specific scenario. If your need is to generate structured teaching content, Flowith currently appears to be a choice worth trying; if you just need quick research and summarization, Manus is still a solid option; and Google Deep Research may be better suited for pure-text deep research report scenarios.

It's worth noting that the AI agent field is in a rapid iteration phase, with each product's capability boundaries potentially changing every few weeks. This article's test results reflect performance at a specific point in time on a specific task, and do not represent the full capabilities of these products. I recommend testing with your own actual tasks when choosing an AI agent, rather than blindly following trends. After all, the tool that truly helps you improve efficiency is your real "productivity champion."

Key Takeaways

• Three AI agents (Manus, Google Deep Research, Flowith) were tested with the same prompt to generate Kafka teaching courseware and speaker notes
• Flowith performed best with clear courseware structure, logical chunking, and highest task completion
• Google Deep Research performed worst with chaotic HTML output and missing speaker notes—task incomplete
• Manus was adequate, with complete content but entirely text-based courseware lacking visual hierarchy
• Brand recognition doesn't equal actual capability—choose AI tools based on real-task testing