Skip to main content
Glama

verify_task

Validate task completion by checking if all requirements and technical standards are fully met, using a unique task ID to ensure accuracy and completeness.

Instructions

Comprehensively verify task completion, ensuring all requirements and technical standards are met without missing details

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
taskIdYesUnique identifier of the task to verify, must be an existing valid task ID in the system

Implementation Reference

  • Main execution logic for verify_task tool: fetches task by ID, validates status is IN_PROGRESS, generates and returns verification prompt.
    export async function verifyTask({ taskId }: z.infer<typeof verifyTaskSchema>) {
      const task = await getTaskById(taskId);
    
      if (!task) {
        return {
          content: [
            {
              type: "text" as const,
              text: `## System Error\n\nTask with ID \`${taskId}\` not found. Please use the "list_tasks" tool to confirm a valid task ID before trying again.`,
            },
          ],
          isError: true,
        };
      }
    
      if (task.status !== TaskStatus.IN_PROGRESS) {
        return {
          content: [
            {
              type: "text" as const,
              text: `## Status Error\n\nTask "${task.name}" (ID: \`${task.id}\`) current status is "${task.status}", not in progress state, cannot be verified.\n\nOnly tasks in "in progress" state can be verified. Please use the "execute_task" tool to start task execution first.`,
            },
          ],
          isError: true,
        };
      }
    
      // Use prompt generator to get the final prompt
      const prompt = getVerifyTaskPrompt({ task });
    
      return {
        content: [
          {
            type: "text" as const,
            text: prompt,
          },
        ],
      };
    }
  • Zod schema defining input for verify_task: requires taskId as UUID string.
    export const verifyTaskSchema = z.object({
      taskId: z
        .string()
        .uuid({ message: "Invalid task ID format, please provide a valid UUID format" })
        .describe("Unique identifier of the task to verify, must be an existing valid task ID in the system"),
    });
  • src/index.ts:269-275 (registration)
    Tool registration in ListToolsRequest handler: defines name, description from template, and converts schema to JSON schema.
    {
      name: "verify_task",
      description: loadPromptFromTemplate(
        "toolsDescription/verifyTask.md"
      ),
      inputSchema: zodToJsonSchema(verifyTaskSchema),
    },
  • src/index.ts:459-472 (registration)
    Dispatch handler in CallToolRequest switch: parses arguments with schema, saves to history if enabled, calls verifyTask function.
    case "verify_task":
      parsedArgs = await verifyTaskSchema.safeParseAsync(
        request.params.arguments
      );
      if (!parsedArgs.success) {
        throw new Error(
          `Invalid arguments for tool ${request.params.name}: ${parsedArgs.error.message}`
        );
      }
      taskId = parsedArgs.data.taskId;
      await saveRequest();
      result = await verifyTask(parsedArgs.data);
      await saveResponse(result);
      return result;
  • Helper function to generate the verification prompt using task details and templates.
    export function getVerifyTaskPrompt(params: VerifyTaskPromptParams): string {
      const { task } = params;
      const indexTemplate = loadPromptFromTemplate("verifyTask/index.md");
      const prompt = generatePrompt(indexTemplate, {
        name: task.name,
        id: task.id,
        description: task.description,
        notes: task.notes || "no notes",
        verificationCriteria:
          task.verificationCriteria || "no verification criteria",
        implementationGuideSummary:
          extractSummary(task.implementationGuide, 200) ||
          "no implementation guide",
        analysisResult:
          extractSummary(task.analysisResult, 300) || "no analysis result",
      });
    
      // Load possible custom prompt
      return loadPrompt(prompt, "VERIFY_TASK");
    }
Behavior2/5

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions 'verifying completion' and 'ensuring requirements are met', which suggests a read-only validation function, but doesn't disclose whether this changes task state, requires specific permissions, has side effects, or what the verification output entails. For a tool with zero annotation coverage, this is inadequate.

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 a single, relatively concise sentence that front-loads the main purpose. However, it could be more structured by separating verification scope from standards checking, and it includes some redundant phrasing ('without missing details' overlaps with 'comprehensively').

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 complexity of verification in a task management context, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'verification' entails operationally, what criteria are used, how results are returned, or how it differs from related tools. This leaves significant gaps for an AI agent to understand the tool's full context.

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

Parameters4/5

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

The description adds no parameter-specific information beyond what the schema provides (100% coverage with a well-described 'taskId' parameter). Since there's only one parameter and schema coverage is complete, the baseline is high. The description doesn't compensate but doesn't need to, earning a 4 for not introducing confusion.

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

Purpose3/5

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

The description states the tool 'comprehensively verify task completion' which indicates a verification function, but it's vague about what 'comprehensively' entails and doesn't clearly differentiate from siblings like 'complete_task' or 'get_task_detail'. It mentions 'ensuring all requirements and technical standards are met' which adds some specificity, but remains somewhat abstract.

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

Usage Guidelines2/5

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

No explicit guidance on when to use this tool versus alternatives like 'complete_task' (which might mark a task as done) or 'get_task_detail' (which might retrieve task information). The description implies usage after task completion but doesn't specify prerequisites, timing, or exclusions relative to other tools.

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

Related 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/liorfranko/mcp-chain-of-thought'

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