Skip to main content
Glama

metacognitivemonitoring

Systematically monitor knowledge boundaries, claim certainty, and reasoning biases to improve decision-making quality through structured self-assessment.

Instructions

A detailed tool for systematic self-monitoring of knowledge and reasoning quality. This tool helps models track knowledge boundaries, claim certainty, and reasoning biases. It provides a framework for metacognitive assessment across various domains and reasoning tasks.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
taskYes
stageYes
knowledgeAssessmentNo
claimsNo
reasoningStepsNo
overallConfidenceYes
uncertaintyAreasYes
recommendedApproachYes
monitoringIdYesUnique identifier for this monitoring session
iterationYesCurrent iteration of the monitoring process
suggestedAssessmentsNo
nextAssessmentNeededYesWhether further assessment is needed

Implementation Reference

  • The `processMetacognitiveMonitoring` method serves as the handler for the tool, validating the input and processing the request.
    public processMetacognitiveMonitoring(input: unknown): { content: Array<{ type: string; text: string }>; isError?: boolean } {
      try {
        const validatedData = this.validateInputData(input);
        const formattedOutput = this.formatOutput(validatedData);
        console.error(formattedOutput);
    
        return {
          content: [{
            type: "text",
            text: JSON.stringify({
              task: validatedData.task,
              stage: validatedData.stage,
              monitoringId: validatedData.monitoringId,
              iteration: validatedData.iteration,
              overallConfidence: validatedData.overallConfidence,
              nextAssessmentNeeded: validatedData.nextAssessmentNeeded,
              status: 'success'
            }, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: "text",
            text: JSON.stringify({
              error: error instanceof Error ? error.message : String(error),
              status: 'failed'
            }, null, 2)
          }],
          isError: true
        };
      }
    }
  • Helper method to validate the input data structure for the tool.
    private validateInputData(input: unknown): MetacognitiveMonitoringData {
      const data = input as MetacognitiveMonitoringData;
      if (!data.task || !data.stage || !data.monitoringId) {
        throw new Error("Invalid input for MetacognitiveMonitoring: Missing required fields.");
      }
      if (typeof data.overallConfidence !== 'number' || data.overallConfidence < 0 || data.overallConfidence > 1) {
        throw new Error("Invalid overallConfidence value for MetacognitiveMonitoringData.");
      }
      if (typeof data.iteration !== 'number' || data.iteration < 0) {
        throw new Error("Invalid iteration value for MetacognitiveMonitoringData.");
      }
      if (typeof data.nextAssessmentNeeded !== 'boolean') {
        throw new Error("Invalid nextAssessmentNeeded value for MetacognitiveMonitoringData.");
      }
      return data;
    }
  • Helper method to format the output of the tool for display.
    private formatOutput(data: MetacognitiveMonitoringData): string {
      const { task, stage, overallConfidence, uncertaintyAreas, recommendedApproach, iteration } = data;
      
      let output = `\n${chalk.bold.blue('Metacognitive Monitoring')}\n`;
      output += `${chalk.bold.green('Task:')} ${task}\n`;
      output += `${chalk.bold.yellow('Stage:')} ${stage} (Iteration: ${iteration})\n`;
      output += `${chalk.bold.magenta('Overall Confidence:')} ${(overallConfidence * 100).toFixed(1)}%\n`;
      
      // Knowledge Assessment
      if (data.knowledgeAssessment) {
        const ka = data.knowledgeAssessment;
        output += `\n${chalk.bold.cyan('Knowledge Assessment:')}\n`;
        output += `${chalk.bold('Domain:')} ${ka.domain}\n`;
        output += `${chalk.bold('Level:')} ${ka.knowledgeLevel} (${(ka.confidenceScore * 100).toFixed(1)}% confidence)\n`;
        output += `${chalk.bold('Evidence:')} ${ka.supportingEvidence}\n`;
        
        if (ka.knownLimitations.length > 0) {
          output += `${chalk.bold('Known Limitations:')}\n`;
          ka.knownLimitations.forEach((limitation, i) => {
            output += `  ${chalk.bold(`${i+1}.`)} ${limitation}\n`;
          });
        }
      }
      
      // Claims
      if (data.claims && data.claims.length > 0) {
        output += `\n${chalk.bold.green('Claims:')}\n`;
        data.claims.forEach((claim, i) => {
          output += `${chalk.bold(`Claim ${i+1}:`)} ${claim.claim}\n`;
          output += `  ${chalk.bold('Status:')} ${claim.status} (${(claim.confidenceScore * 100).toFixed(1)}% confidence)\n`;
          output += `  ${chalk.bold('Evidence:')} ${claim.evidenceBasis}\n`;
          
          if (claim.alternativeInterpretations && claim.alternativeInterpretations.length > 0) {
            output += `  ${chalk.bold('Alternative Interpretations:')}\n`;
            claim.alternativeInterpretations.forEach((alt, j) => {
              output += `    ${chalk.bold(`${j+1}.`)} ${alt}\n`;
            });
          }
        });
      }
      
      // Reasoning Steps
      if (data.reasoningSteps && data.reasoningSteps.length > 0) {
        output += `\n${chalk.bold.yellow('Reasoning Steps:')}\n`;
        data.reasoningSteps.forEach((step, i) => {
          output += `${chalk.bold(`Step ${i+1}:`)} ${step.step}\n`;
          output += `  ${chalk.bold('Logical Validity:')} ${(step.logicalValidity * 100).toFixed(1)}%\n`;
          output += `  ${chalk.bold('Inference Strength:')} ${(step.inferenceStrength * 100).toFixed(1)}%\n`;
          
          if (step.assumptions.length > 0) {
            output += `  ${chalk.bold('Assumptions:')}\n`;
            step.assumptions.forEach((assumption, j) => {
              output += `    ${chalk.bold(`${j+1}.`)} ${assumption}\n`;
            });
          }
          
          if (step.potentialBiases.length > 0) {
            output += `  ${chalk.bold('Potential Biases:')}\n`;
            step.potentialBiases.forEach((bias, j) => {
              output += `    ${chalk.bold(`${j+1}.`)} ${bias}\n`;
            });
          }
        });
      }
      
      // Uncertainty Areas
      if (uncertaintyAreas.length > 0) {
        output += `\n${chalk.bold.red('Uncertainty Areas:')}\n`;
        uncertaintyAreas.forEach((area, i) => {
          output += `${chalk.bold(`${i+1}.`)} ${area}\n`;
        });
      }
      
      // Recommended Approach
      output += `\n${chalk.bold.cyan('Recommended Approach:')}\n${recommendedApproach}\n`;
      
      // Next Steps
      if (data.nextAssessmentNeeded) {
        output += `\n${chalk.green('Further assessment needed.')}\n`;
        if (data.suggestedAssessments && data.suggestedAssessments.length > 0) {
          output += `${chalk.bold('Suggested Assessments:')} ${data.suggestedAssessments.join(', ')}\n`;
        }
      } else {
        output += `\n${chalk.cyan('Assessment complete.')}\n`;
      }
      
      return output;
    }
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it explains what aspects are monitored, it fails to describe what happens upon invocation—whether data persists, what constitutes successful completion, or if there are side effects. It does not clarify the relationship between iterations or how the monitoringId is managed.

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 three-sentence structure is reasonably efficient and front-loaded with the core definition. However, the third sentence ('It provides a framework...') partially restates the first sentence's concept of being a 'detailed tool for systematic self-monitoring,' slightly diluting the conciseness.

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 high complexity (12 parameters including nested arrays/objects, 8 required fields, no output schema, no annotations), the description is insufficient. It lacks explanation of the return value, the relationship between stage iterations, and practical guidance for constructing the required nested objects (e.g., what constitutes valid supportingEvidence or knownLimitations).

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?

With only 25% schema description coverage and complex nested objects (knowledgeAssessment, claims, reasoningSteps), the description inadequately compensates for the schema gaps. While it mentions 'knowledge boundaries,' 'claim certainty,' and 'reasoning biases' mapping to the three main object groups, it provides no guidance on how to populate these structures, the expected format for supportingEvidence, or how the stage enum values flow through a workflow.

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

Purpose4/5

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

The description clearly defines the tool as being for 'systematic self-monitoring of knowledge and reasoning quality' with specific actions (track knowledge boundaries, claim certainty, reasoning biases). The term 'self-monitoring' distinguishes it from sibling tools focused on external collaboration (collaborativereasoning), debugging (debuggingapproach), or output generation. However, it lacks explicit contrast with other cognitive tools like sequentialthinking or structuredargumentation.

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?

The description implies usage contexts ('metacognitive assessment across various domains'), but provides no explicit guidelines on when to use this versus the ten sibling reasoning tools. It states what the tool helps with but not when it is the optimal choice over alternatives like sequentialthinking or scientificmethod.

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/chirag127/Clear-Thought-MCP-server'

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