Skip to main content
Glama

manus_task_create

Create an asynchronous Manus task using text, file, or voice content. Configure project, locale, interactive mode, agent profile, connectors, and skills. Run in background and poll or wait for completion.

Instructions

Create a new Manus task. Runs asynchronously; poll manus_task_list_messages or use manus_task_wait for completion. Supports text/file/voice content parts, connectors, skills, project scoping, and interactive mode.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
messageYes
project_idNo
localeNo
interactive_modeNo
hide_in_task_listNo
share_visibilityNo
agent_profileNo
titleNo

Implementation Reference

  • Handler function for the manus_task_create tool. Decorated with @manus_tool, it makes a POST request to /v2/task.create.
    @manus_tool(
        name="manus_task_create",
        description=(
            "Create a new Manus task. Runs asynchronously; poll manus_task_list_messages or use "
            "manus_task_wait for completion. Supports text/file/voice content parts, connectors, "
            "skills, project scoping, and interactive mode."
        ),
        input_schema=TaskCreateRequest,
        output_schema=TaskCreateResponse,
    )
    async def task_create(req: TaskCreateRequest, ctx: ToolCtx) -> TaskCreateResponse:
        return await ctx.client.call(
            "POST",
            "/v2/task.create",
            json_body=req,
            response_model=TaskCreateResponse,
            rate_limit_key="task.create",
        )
  • Input and output Pydantic schemas for task.create. TaskCreateRequest defines the message block and optional fields; TaskCreateResponse wraps the created task ID and URLs.
    class TaskCreateRequest(ManusModel):
        message: MessageBlock
        project_id: str | None = None
        locale: str | None = None
        interactive_mode: bool | None = None
        hide_in_task_list: bool | None = None
        share_visibility: ShareVisibility | None = None
        agent_profile: AgentProfile | None = None
        title: str | None = None
  • The @manus_tool decorator that registers manus_task_create into the global _REGISTRY dict when the tasks module is imported.
    def manus_tool(
        *,
        name: str,
        description: str,
        input_schema: type[TIn],
        output_schema: type[TOut],
        rate_limit_key: str | None = None,
    ) -> Callable[
        [Callable[[TIn, ToolCtx], Awaitable[TOut]]], Callable[[TIn, ToolCtx], Awaitable[TOut]]
    ]:
        """Decorator registering `handler` as a tool with the given metadata."""
    
        def wrap(
            handler: Callable[[TIn, ToolCtx], Awaitable[TOut]],
        ) -> Callable[[TIn, ToolCtx], Awaitable[TOut]]:
            if name in _REGISTRY:
                raise RuntimeError(f"Duplicate tool name: {name}")
            _REGISTRY[name] = ToolDef(
                name=name,
                description=description,
                input_schema=input_schema,
                output_schema=output_schema,
                handler=handler,
                rate_limit_key=rate_limit_key,
            )
            return handler
    
        return wrap
  • MessageBlock helper schema used as the 'message' field in TaskCreateRequest. Defines content (text or file/voice parts), connectors, and skills.
    class MessageBlock(ManusModel):
        content: str | list[ContentPart]
        connectors: list[str] | None = None
        enable_skills: list[str] | None = None
        force_skills: list[str] | None = None
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses the async execution behavior and lists supported features but does not mention auth requirements, rate limits, or potential side effects. The async disclosure is valuable, but other behaviors are omitted.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short (two sentences). The first sentence is crisp; the second is a longer list but still efficient. There's minimal waste, though the list could be more structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (8 parameters, nested $defs, no output schema), the description is incomplete. It fails to explain the return value (e.g., task ID), required permissions, or default behaviors. The absence of annotations and output schema amplifies the gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 0% description coverage and 8 parameters. The description only lists supported features (text/file/voice content, connectors, skills, project scoping, interactive mode) without detailing each parameter's semantics or constraints. It adds some high-level context but insufficient for precise invocation of all parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description begins with 'Create a new Manus task.', a specific verb and resource. Sibling tools like manus_task_list, manus_task_delete, etc., clearly distinguish this as the creation operation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains that the task runs asynchronously and advises polling manus_task_list_messages or using manus_task_wait for completion. This gives clear post-usage guidance. However, it does not explicitly state when not to use this tool (e.g., to avoid creating duplicate tasks or when a simple query suffices).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/aruxojuyu665/Manus-MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server