Understanding the Teamo‑Strategy Skill in OpenClaw: How It Decomposes Complex Tasks

Understanding the Teamo‑Strategy Skill in OpenClaw: How It Decomposes

Complex Tasks

The OpenClaw repository hosts a collection of reusable skills that extend the
capabilities of AI agents. Among them, the Teamo‑Strategy skill stands out
as a top‑level cognitive task decomposer and strategic commander. This article
explains what the skill does, how its internal workflow operates, and why it
can be a game‑changer for anyone looking to automate complex, multi‑step
projects.

What Is the Teamo‑Strategy Skill?

At its core, Teamo‑Strategy is designed to receive a user request, analyze
what information is missing, ask for the necessary background material, and
then break the overall task into smaller, independent cognitive sub‑tasks.
Those sub‑tasks can be executed in parallel or sequentially, depending on
their dependencies, and the results are finally merged into a coherent output.

The skill is defined in the file skills/skills/urrrich/teamo-
strategy/SKILL.md within the OpenClaw GitHub repository. Although the file is
relatively short (21 lines), it encodes a sophisticated reasoning loop that
mirrors how a human project manager would approach a complex assignment.

Core Mission and the Iron Triangle

The skill’s documentation outlines a "Core Mission" and an "Iron Triangle"
that govern its behavior:

• Strategic Segmentation : Decompose complex tasks by functional areas or information modules. Only decompose the user‑provided information; do not add extra explanation or interpretation.
• Context Completeness : Before any work begins, proactively identify and request missing key background information.
• The Iron Triangle consists of three immutable rules:
  1. User Input is Truth : Never alter proper nouns, version numbers, or specific terminology supplied by the user.
  2. Context is Quality : For complex tasks, requesting background material is a core duty, not a disturbance.
  3. Lossless Attachment Transmission : When delegating sub‑tasks, all required attachments must be passed along unchanged.

These principles ensure that the skill stays faithful to the user’s intent
while constantly seeking the information needed to produce high‑quality
results.

The Brain: Thinking and Execution Process (Chain‑of‑Thought)

Teamo‑Strategy follows a explicit Chain‑of‑Thought (CoT) process after
receiving a task. The process is divided into five steps:

Step 1: Context Gap Analysis (Critical Upgrade)

Before any decomposition, the skill examines the task’s complexity and type.
It asks itself: "If I want to output a perfect 100/100 result, what key puzzle
pieces am I still missing?" This analysis includes:

• Judgment of Detail Granularity Required by User : The skill infers the desired depth of detail from the user’s phrasing. A vague request suggests a ~5,000‑word output; a detailed request points to 10k‑30k words; a request for exhaustive detail implies over 90,000 words. Importantly, the skill never mentions word counts directly to the user.
• Scenario Judgment : Simple tasks (e.g., "Check tomorrow’s weather") skip directly to Step 3. Complex or customized tasks (e.g., "Write an event plan", "Conduct a competitor analysis") trigger the gap analysis.
• Gap Scan List (Examples) : The skill looks for missing pieces such as background/persona, resources/constraints, history/experience, and materials/files.
• Decision Point : If any key information is missing, decomposition stops and the skill invokes message_ask_user to request the needed data.

Step 2: Intent Confirmation & Material Request (Interaction)

When the skill decides to ask the user for more information, it does so in a
professional, checklist‑style manner. Instead of a vague "What do you need to
add?", it lists concrete items, for example:

• Project budget range
• Introduction to the company’s similar past cases
• Target customer persona

It also encourages the user to upload relevant documents (PDF, Word, CSV) as
attachments, explaining that this will greatly improve result accuracy.

Step 3: Module Decomposition (The "Cut")

Once sufficient context is gathered (or the user indicates no further
materials are needed), Teamo‑Strategy proceeds to decompose the task into 1‑4
informationally dimension‑independent cognitive sub‑tasks. The decomposition
obeys the MECE principle: each sub‑task is Mutually Exclusive and Collectively
Exhaustive.

Step 4: Dependency Graph & Distribution (The "Flow")

The skill then builds a dependency graph:

• Concurrent Calls : Sub‑tasks with no dependencies are distributed in parallel to multiple instances of Teamo‑Strategy, boosting efficiency.
• Serial Calls : For dependent sub‑tasks, the predecessor is completed first; its output is passed as context to the next sub‑task.
• Lossless Attachment Transmission : All required attachment files are forwarded via the attached_files field.
• Language Requirement : The task_description for each sub‑task must be in Chinese.
• Word Count Requirement : Based on the granularity judgment from Step 1, the skill assigns a specific word‑count target to each sub‑task and communicates that target to the subordinate.

Each subordinate receives a chapter‑style template: they must use "Chapter X:
xxxx" as the chapter title and must not further subdivide the chapter with
additional headings.

Step 5: Receiving & Integrating

After all sub‑tasks return their results, the originating Teamo‑Strategy
instance:

1. Completely reads each result document.
2. Invokes the create_wiki_document tool to produce an Executive Summary of the entire task.
3. Names the summary document after a generalized name for the whole task (e.g., "Pop Mart Marketing Strategy Panoramic Plan").

The final output is a cohesive, well‑structured document that combines the
executive summary with the detailed chapter outputs.

Practical Example: Handling a Customized Event Plan

The skill’s documentation includes a concrete walkthrough that illustrates the
whole flow:

User Input : "Help me write an offline pop‑up store plan for a new
product launch for a well‑known FMCG brand."

Thinking Process :

1. Gap Analysis : The task is high‑complexity. Missing pieces include the specific brand (to understand tonality), the new product (its selling points), and the budget (feasibility). Writing blindly would yield only a generic template.
2. Strategy : Request materials.
3. Action : Call message_ask_user with a checklist‑style request.

Tool Call (message_ask_user) : "Received. To customize a highly feasible
plan for you, rather than just a generic template, I suggest you supplement
the following background materials (attachments supported):

1. Brand and Product Manual – to understand brand tonality and core selling points.
2. Budget Range – determines whether to aim for ‘small and beautiful’ or ‘high‑profile and aggressive’.
3. Past Cases – any satisfactory past event cases for reference.
4. Target Audience – which user types the pop‑up store wants to attract.
5. Complexity Confirmation – desired granularity of detail (methodology only vs. exhaustive detail). You can send files directly or describe briefly in text."

Once the user supplies the requested information, the skill proceeds through
Steps 3‑5, delivering a tailored, high‑quality event plan that reflects the
brand’s identity, budget constraints, and audience preferences.

Why This Skill Matters for AI Workflows

Most AI agents excel at generating text given a prompt, but they often
struggle with:

• Knowing what information they lack before starting.
• Breaking down a large, ambiguous request into manageable pieces.
• Coordinating multiple subprocesses while preserving context.

Teamo‑Strategy directly addresses these gaps. By enforcing a disciplined
context‑gathering phase, it reduces the risk of hallucinations or irrelevant
output. The MECE‑based decomposition ensures that no aspect of the task is
overlooked or duplicated. Parallel execution of independent sub‑tasks cuts
down overall latency, while the dependency‑aware serial execution guarantees
logical flow.

Moreover, the skill’s insistence on preserving user‑provided terminology and
attachments makes it suitable for professional domains where precision
matters—such as marketing strategy, technical documentation, financial
analysis, or legal research.

How to Use the Skill in Your Own Projects

If you are building an agent framework that can load OpenClaw skills,
integrating Teamo‑Strategy is straightforward:

1. Add the skill’s directory (skills/skills/urrrich/teamo-strategy) to your skill repository.
2. Ensure your agent can invoke the two tools referenced in the skill: message_ask_user (to interact with the user) and create_wiki_document (to generate the final wiki‑style output).
3. When a user submits a complex request, route it to the Teamo‑Strategy skill. The skill will handle the rest, asking for missing context, decomposing the task, and assembling the final answer.
4. Optionally, tune the granularity judgments by providing explicit guidance in the user’s prompt (e.g., "I need a high‑level overview" vs. "I need every step detailed").

Developers can also create wrapper skills that call Teamo‑Strategy for
specific domains (e.g., a "Marketing Campaign Planner" that pre‑populates
certain context fields).

Limitations and Best Practices

While powerful, the skill is not a silver bullet. Keep the following
considerations in mind:

• Dependency on Tool Availability : The skill relies on message_ask_user and create_wiki_document. If your environment does not support these tools, you must provide equivalents.
• Language Constraint : Internally, the skill requires Chinese for task_description. If your workflow operates primarily in another language, you will need a translation layer.
• Over‑Requests : In cases where the user provides minimal context, the skill may ask for many details, which could be perceived as burdensome. Setting clear expectations up front (e.g., "I can work with high‑level info; let me know if you need depth") mitigates this.
• Word‑Count Estimation : The skill’s internal word‑count mapping is heuristic. For strict length requirements, you may need to post‑process the output or provide explicit limits in the user request.

Best practice: treat Teamo‑Strategy as a project manager. Supply it with as
much relevant context as you can initially, be ready to answer its follow‑up
questions, and review the generated executive summary for alignment with your
goals.

Conclusion

The Teamo‑Strategy skill exemplifies how a well‑designed reasoning loop can
elevate an AI agent from a simple text generator to a strategic partner
capable of handling intricate, real‑world projects. By enforcing strict
context completeness, applying MECE‑based decomposition, and coordinating
parallel and serial sub‑task execution, it delivers outputs that are both
comprehensive and coherent.

Whether you are drafting a marketing plan, conducting a competitor analysis,
or producing a technical report, integrating Teamo‑Strategy into your agent’s
skill set can save time, reduce errors, and improve the quality of the final
deliverable. Explore the skill in the OpenClaw repository, experiment with its
workflow, and discover how structured AI reasoning can transform your
automation initiatives.

Skill can be found at:
strategy/SKILL.md>