plith

Before executing any LLM task, check if an identical or semantically similar task has already been completed. Returns cached result on hit, saving one LLM call. On a miss, execute your task and call dedupq_complete to cache the result for future hits. Costs 1 credit.

{
  "type": "object",
  "properties": {
    "content": {
      "type": "string",
      "description": "The task content to check for duplicates. This is hashed and embedded for matching."
    },
    "task_id": {
      "type": "string",
      "description": "Optional caller task ID for tracing and cross-referencing with BurnRate."
    },
    "hash_only": {
      "type": "boolean",
      "description": "If true, skip vector similarity search and use exact hash matching only. Default: false."
    },
    "similarity_threshold": {
      "type": "number",
      "description": "Cosine similarity threshold for semantic matching, 0.0 to 1.0. Default: 0.80."
    }
  },
  "required": [
    "content"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "description": "hit | miss | in_progress"
    },
    "match": {
      "type": "object",
      "properties": {
        "task_id": {
          "type": "string"
        },
        "similarity": {
          "type": "number"
        },
        "match_type": {
          "type": "string"
        },
        "cached_at": {
          "type": "string"
        }
      }
    },
    "content_hash": {
      "type": "string"
    },
    "cache_hit": {
      "type": "string"
    },
    "cache_age_seconds": {
      "type": "number"
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

After executing a task, store the result so future identical or similar tasks return a cache hit via dedupq_check. Costs 2 credits.

{
  "type": "object",
  "properties": {
    "content": {
      "type": "string",
      "description": "Original task content. Used to compute hash and embedding for future matching."
    },
    "result": {
      "description": "The task result to cache. Can be any JSON value."
    },
    "task_id": {
      "type": "string",
      "description": "Optional task ID. Used as the database row ID if provided."
    },
    "hash_only": {
      "type": "boolean",
      "description": "If true, skip embedding generation. Default: false."
    }
  },
  "required": [
    "content",
    "result"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "stored": {
      "type": "boolean"
    },
    "task_id": {
      "type": "string"
    },
    "content_hash": {
      "type": "string"
    },
    "has_embedding": {
      "type": "boolean"
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Before executing a multi-step agent plan, estimate the total LLM cost. Returns per-step breakdown and optimization suggestions. If the estimate exceeds your budget, pipe the same plan into burnrate_optimize. Costs 1 credit.

{
  "type": "object",
  "properties": {
    "plan": {
      "type": "array",
      "description": "Array of plan steps with provider, model, and token estimates.",
      "items": {
        "type": "object",
        "properties": {
          "step": {
            "type": "string",
            "description": "Step identifier — string label or number."
          },
          "provider": {
            "type": "string",
            "description": "LLM provider: anthropic, openai, google, etc."
          },
          "model": {
            "type": "string",
            "description": "Model name: claude-sonnet-4-6, gpt-4o, etc."
          },
          "estimated_input_tokens": {
            "type": "number",
            "description": "Estimated prompt token count."
          },
          "estimated_output_tokens": {
            "type": "number",
            "description": "Estimated completion token count."
          },
          "cache_read_tokens": {
            "type": "number",
            "description": "Optional. Cached prompt tokens for providers with prompt caching."
          },
          "search_calls": {
            "type": "number",
            "description": "Optional. Number of grounding/search calls (e.g. Gemini Search)."
          }
        },
        "required": [
          "step",
          "provider",
          "model",
          "estimated_input_tokens",
          "estimated_output_tokens"
        ]
      }
    }
  },
  "required": [
    "plan"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "estimate": {
      "type": "object",
      "properties": {
        "steps": {
          "type": "array",
          "items": {
            "type": "object"
          }
        },
        "total_cost_usd": {
          "type": "number"
        },
        "total_cost_usd_formatted": {
          "type": "string"
        },
        "step_count": {
          "type": "number"
        },
        "estimate_complete": {
          "type": "boolean"
        },
        "unrecognized_models": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "recognized_step_count": {
          "type": "number"
        },
        "pricing_as_of": {
          "type": "string"
        },
        "pricing_source": {
          "type": "string"
        }
      }
    },
    "optimization_suggestions": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Log the actual cost of an LLM call after execution. Call this after every LLM request to build calibration data that improves burnrate_estimate accuracy over time. Free — no credits charged. Returns the recorded cost entry with computed margin versus the prior estimate when one exists for this model and token range.

{
  "type": "object",
  "properties": {
    "provider": {
      "type": "string",
      "description": "LLM provider identifier. Supported: anthropic, openai, google, mistral, cohere, deepseek, together, fireworks, groq. Must match the provider of the model used."
    },
    "model": {
      "type": "string",
      "description": "Model identifier as returned by the provider. Examples: claude-sonnet-4-6, gpt-4o, gemini-2.0-flash, mistral-large-latest. Unknown models are accepted but cost may show as $0."
    },
    "input_tokens": {
      "type": "number",
      "description": "Actual prompt tokens used. Must be >= 0."
    },
    "output_tokens": {
      "type": "number",
      "description": "Actual completion tokens used. Must be >= 0."
    },
    "task_id": {
      "type": "string",
      "description": "Optional task ID for cross-referencing spend with DedupQ deduplication results. Use the same task_id passed to dedupq_check to link cost tracking with deduplication."
    },
    "cache_read_tokens": {
      "type": "number",
      "description": "Optional. Cache-read tokens."
    }
  },
  "required": [
    "provider",
    "model",
    "input_tokens",
    "output_tokens"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "tracked": {
      "type": "boolean"
    },
    "record_id": {
      "type": "string"
    },
    "provider": {
      "type": "string"
    },
    "model": {
      "type": "string"
    },
    "input_tokens": {
      "type": "number"
    },
    "output_tokens": {
      "type": "number"
    },
    "actual_cost_usd": {
      "type": "number"
    },
    "actual_cost_usd_formatted": {
      "type": "string"
    },
    "pricing_found": {
      "type": "boolean"
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Get a cheaper equivalent plan by substituting models with lower-cost alternatives. Call after burnrate_estimate if the estimated cost exceeds your budget. Returns the optimized plan with substituted models, new per-step costs, total savings, and whether the target_budget is met. Optionally set target_budget to constrain the optimization. Costs 1 credit.

{
  "type": "object",
  "properties": {
    "plan": {
      "type": "array",
      "description": "Array of plan steps. Same schema as burnrate_estimate: each step needs step, provider, model, estimated_input_tokens, estimated_output_tokens.",
      "items": {
        "type": "object",
        "properties": {
          "step": {
            "type": "string",
            "description": "Step identifier — string label or number."
          },
          "provider": {
            "type": "string",
            "description": "LLM provider."
          },
          "model": {
            "type": "string",
            "description": "Model name."
          },
          "estimated_input_tokens": {
            "type": "number",
            "description": "Estimated input tokens."
          },
          "estimated_output_tokens": {
            "type": "number",
            "description": "Estimated output tokens."
          }
        },
        "required": [
          "step",
          "provider",
          "model",
          "estimated_input_tokens",
          "estimated_output_tokens"
        ]
      }
    },
    "target_budget": {
      "type": "number",
      "description": "Optional. Target total cost in USD."
    }
  },
  "required": [
    "plan"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "original": {
      "type": "object",
      "properties": {
        "total_cost_usd": {
          "type": "number"
        },
        "total_cost_usd_formatted": {
          "type": "string"
        }
      }
    },
    "optimized": {
      "type": "object",
      "properties": {
        "total_cost_usd": {
          "type": "number"
        },
        "total_cost_usd_formatted": {
          "type": "string"
        },
        "total_savings_usd": {
          "type": "number"
        },
        "total_savings_pct": {
          "type": "number"
        }
      }
    },
    "steps": {
      "type": "array",
      "items": {
        "type": "object"
      }
    },
    "suggestions": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Get today's tracked LLM spend, per-model breakdown, projection, and budget alerts. Free — no credits charged.

{
  "type": "object",
  "properties": {
    "daily_limit": {
      "type": "number",
      "description": "Optional. Daily budget in USD (e.g., 10.0 for a $10/day cap). Enables budget alerts and remaining-balance calculation."
    }
  },
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "date": {
      "type": "string"
    },
    "spend": {
      "type": "object",
      "properties": {
        "total_usd": {
          "type": "number"
        },
        "total_usd_formatted": {
          "type": "string"
        },
        "total_calls": {
          "type": "number"
        },
        "by_model": {
          "type": "array",
          "items": {
            "type": "object"
          }
        }
      }
    },
    "projection": {
      "type": "object",
      "properties": {
        "hourly_rate_usd": {
          "type": "number"
        },
        "projected_day_total_usd": {
          "type": "number"
        },
        "hours_remaining": {
          "type": "number"
        }
      }
    },
    "alerts": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

After your agent generates output, validate it against your rules before shipping. Runs deterministic checks (regex, JSON schema, syntax) plus optional LLM-powered tone and factual analysis. Returns a structured verdict (pass, warn, or fail) with a 0-100 score and per-check issue details. Use qualitygate_trends to spot recurring failure patterns over time. Variable cost: 1 credit per deterministic check, 8 credits per LLM check.

{
  "type": "object",
  "properties": {
    "output": {
      "type": "string",
      "description": "The agent output text to validate."
    },
    "directives": {
      "type": "array",
      "description": "Directive objects. Types: must_include, must_not_include, must_match, must_not_match, must_contain, must_not_contain, min_length, max_length.",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "description": "Directive type."
          },
          "value": {
            "type": "string",
            "description": "Directive value — string pattern, regex, keyword array (as comma-separated string), or number (as string). Interpreted based on directive type."
          },
          "name": {
            "type": "string",
            "description": "Optional directive name."
          }
        },
        "required": [
          "type",
          "value"
        ]
      }
    },
    "schema": {
      "type": "object",
      "description": "JSON Schema to validate output against."
    },
    "language": {
      "type": "string",
      "description": "Code language for syntax check: json, python, javascript, typescript."
    },
    "check_types": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "directive_compliance",
          "schema_validation",
          "code_syntax",
          "tone",
          "factual_claims"
        ]
      },
      "description": "Checks to run. Auto-inferred if omitted."
    },
    "override": {
      "type": "boolean",
      "description": "Force pass. Requires override_reason."
    },
    "override_reason": {
      "type": "string",
      "description": "Required when override is true."
    }
  },
  "required": [
    "output"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "verdict": {
      "type": "string",
      "enum": [
        "pass",
        "warn",
        "fail"
      ]
    },
    "checks_run": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "issues": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string"
          },
          "severity": {
            "type": "string"
          },
          "message": {
            "type": "string"
          }
        }
      }
    },
    "summary": {
      "type": "object",
      "properties": {
        "total": {
          "type": "number"
        },
        "errors": {
          "type": "number"
        },
        "warnings": {
          "type": "number"
        }
      }
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Evaluate a proposed agent action against your governance policies. Returns allow or deny with the matched policy reason. Requires at least one active policy created via guardrail_create_policy. Deterministic rule evaluation — no LLM. Costs 1 credit.

{
  "type": "object",
  "properties": {
    "agent_id": {
      "type": "string",
      "description": "Agent identifier."
    },
    "proposed_action": {
      "type": "object",
      "description": "Action to evaluate. Must contain a 'type' field. Example: {\"type\": \"http_request\", \"url\": \"https://external.example.com\"} or {\"type\": \"file_write\", \"path\": \"/etc/config\"}.",
      "properties": {
        "type": {
          "type": "string",
          "description": "Action type: http_request, delete_file, send_email, etc."
        }
      },
      "required": [
        "type"
      ]
    }
  },
  "required": [
    "agent_id",
    "proposed_action"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "decision": {
      "type": "string",
      "enum": [
        "allow",
        "deny",
        "stub"
      ]
    },
    "reason": {
      "type": "string"
    },
    "policy_id": {
      "type": "string"
    },
    "audit_id": {
      "type": "string"
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Create a persistent governance policy that guardrail_check evaluates on every subsequent call. Define rules using and/or/not operators over action types, resource patterns, and budget thresholds. Call this before using guardrail_check — checks require at least one active policy. Policies persist until explicitly deleted. Duplicate policy names return an error. Returns the created policy with its ID and active status.

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Unique policy name per org. Examples: 'no-delete-in-prod', 'budget-cap-50', 'pii-block'."
    },
    "description": {
      "type": "string",
      "description": "Optional human-readable summary of what this policy enforces. Returned in guardrail_check responses and guardrail_list_policies output for auditability."
    },
    "rules": {
      "type": "array",
      "description": "Array of rule objects evaluated against the proposed_action in guardrail_check. Leaf operators: eq, starts_with, contains, gt, lt (compare field to value). Compound operators: and, or, not (nest sub-rules in a rules array). Example: [{operator:'eq', field:'type', value:'file_write'}] blocks all file writes. Nested example: [{operator:'and', rules:[{operator:'eq',field:'type',value:'api_call'},{operator:'contains',field:'url',value:'prod'}]}] blocks prod API calls.",
      "items": {
        "type": "object",
        "properties": {
          "operator": {
            "type": "string",
            "description": "Rule operator: eq | starts_with | contains | gt | lt | and | or | not."
          },
          "field": {
            "type": "string",
            "description": "Field path on proposed_action (e.g. 'action_type', 'path', 'amount')."
          },
          "value": {
            "type": "string",
            "description": "Comparison value for leaf operators. String, number, or boolean as string."
          },
          "rules": {
            "type": "array",
            "description": "Nested rules for compound operators (and/or/not)."
          }
        },
        "required": [
          "operator"
        ]
      }
    },
    "action_types": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional. Restrict this policy to only evaluate when proposed_action.type matches one of these values. Examples: ['file_write', 'api_call', 'db_delete']. Omit to apply the policy to all action types regardless of type field."
    },
    "priority": {
      "type": "number",
      "description": "Optional. Evaluation order. Default: 0."
    }
  },
  "required": [
    "name",
    "rules"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "policy": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string"
        },
        "name": {
          "type": "string"
        },
        "description": {
          "type": "string"
        },
        "rules": {
          "type": "array"
        },
        "action_types": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "priority": {
          "type": "number"
        },
        "enabled": {
          "type": "boolean"
        },
        "created_at": {
          "type": "string"
        }
      }
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Check for known failure patterns before executing a task type. Returns pitfalls with severity, fix suggestions, and confidence scores. After your agent runs, submit failures via pitfalldb_report so others benefit. Costs 2 credits.

{
  "type": "object",
  "properties": {
    "task_type": {
      "type": "string",
      "description": "Task category: code_generation, web_search, data_analysis, etc."
    },
    "task_description": {
      "type": "string",
      "description": "Optional. Natural-language task description for semantic search."
    },
    "filters": {
      "type": "object",
      "description": "Optional filters.",
      "properties": {
        "language": {
          "type": "string",
          "description": "Programming language."
        },
        "framework": {
          "type": "string",
          "description": "Framework."
        },
        "provider": {
          "type": "string",
          "description": "LLM provider."
        }
      }
    }
  },
  "required": [
    "task_type"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "pitfalls": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "severity": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "frequency": {
            "type": "string"
          },
          "reports": {
            "type": "number"
          },
          "fix": {
            "type": "string"
          },
          "fix_confidence": {
            "type": "number"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        }
      }
    },
    "total_matching": {
      "type": "number"
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Report an agent failure. PII-scrubbed before storage. Linked to existing pitfalls if similar. Free — no credits charged.

{
  "type": "object",
  "properties": {
    "task_type": {
      "type": "string",
      "description": "Task category."
    },
    "task_description": {
      "type": "string",
      "description": "Description of the failed task."
    },
    "failure": {
      "type": "object",
      "description": "Failure details.",
      "properties": {
        "error_type": {
          "type": "string",
          "description": "Error category: tool_call_ignored, syntax_error, etc."
        },
        "error_message": {
          "type": "string",
          "description": "Error message (PII-scrubbed)."
        },
        "root_cause": {
          "type": "string",
          "description": "Root cause analysis (PII-scrubbed)."
        },
        "fix_applied": {
          "type": "string",
          "description": "Fix applied (PII-scrubbed)."
        },
        "fix_worked": {
          "type": "boolean",
          "description": "Whether the fix worked."
        },
        "language": {
          "type": "string",
          "description": "Programming language."
        },
        "framework": {
          "type": "string",
          "description": "Framework."
        },
        "provider": {
          "type": "string",
          "description": "LLM provider."
        }
      }
    }
  },
  "required": [
    "task_type",
    "task_description",
    "failure"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "report_id": {
      "type": "string"
    },
    "linked_pitfall_id": {
      "type": "string"
    },
    "verified": {
      "type": "boolean"
    },
    "message": {
      "type": "string"
    },
    "request_id": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "fallback_behavior": {
      "type": "string"
    }
  }
}

Before executing a complex task, get a structured workflow plan with per-step cost estimates. Classifies your task, selects the optimal framework sequence, and returns the full plan without executing anything. The response's allowed_modes tells you whether this plan is eligible for direct execution. Free — no credits charged.

{
  "type": "object",
  "properties": {
    "task_description": {
      "type": "string",
      "description": "Natural language description of the task. Be specific — include what you want produced, constraints, and context. Example: 'Design a caching layer for our API gateway with Redis integration.'"
    },
    "task_type": {
      "type": "string",
      "description": "Optional hint to bypass automatic classification. Passing it also removes the slowest classification tiers from the critical path, so send it whenever you know the shape. Multi-step deliverable types: solution_design, requirements_analysis, code_implementation, code_review, bug_fix, root_cause_analysis, incident_response, deployment_execution, competitive_scan, financial_analysis, research_task, documentation, governance_change, compliance_audit, data_security_assessment, performance_optimization, user_story_definition, implementation_prompt_generation. Atomic single-call types, which auto-select direct execution: tag, score, rerank, compose, extract_entities, parse_query, quick_research, quick_classification, quick_extraction, quick_scoring. Call GET /api/rigor/task-types for the full vocabulary with each type's shape."
    },
    "preferences": {
      "type": "object",
      "description": "Optional workflow preferences.",
      "properties": {
        "rigor_level": {
          "type": "string",
          "enum": [
            "quick",
            "standard",
            "thorough"
          ],
          "description": "Review depth. Default auto-detected from task complexity."
        },
        "max_budget_usd": {
          "type": "number",
          "description": "Budget ceiling in USD. Triggers warning if plan exceeds this."
        },
        "require_approval": {
          "type": "boolean",
          "description": "Pause at pending_approval before the final step."
        },
        "approval_before_step": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "description": "Zero-based step indices where approval gates are inserted."
        },
        "skip_frameworks": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Framework names to exclude from the plan."
        },
        "only_frameworks": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Restrict plan to only these frameworks (mutex with skip_frameworks)."
        },
        "add_frameworks": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Inject additional frameworks into the plan."
        },
        "execution": {
          "type": "string",
          "enum": [
            "direct"
          ],
          "description": "Set to 'direct' to compose the plan's content frameworks into a single LLM call and route cost-first, using a per-task-type model floor that moves when a cheaper model earns the work. Research steps, process steps (classification-verify, review protocol, synthesis) and the quality review each remain separate calls, so this is not a one-call-per-workflow guarantee: for atomic task types, which have a single content framework, the call count matches standard execution and the saving is the model. Supplying output_contract replaces the quality-review call with deterministic validation, which is one fewer call. No intermediate outputs. Available at every tier. Auto-selected for atomic task types when no execution preference is given. Falls back to standard execution when combined with require_approval or interactive mode, or when the plan exceeds the composition size limit. Attachments and prior_workflow_id chaining are NOT applied — use standard execution for those."
        },
        "output_contract": {
          "type": "object",
          "description": "Only read when execution is \"direct\". Declares the JSON shape you want back, so the answer is generated against your schema and validated against it before return, instead of returned as prose you have to parse. A conforming run also skips the quality-review call, costing 1 LLM call rather than 2. The schema is closed: a record carrying an undeclared key is rejected exactly like one missing a required key.",
          "properties": {
            "task_type": {
              "type": "string",
              "description": "Your own label for the work. Echoed into telemetry. Not read as a framework name and does not change routing."
            },
            "shape": {
              "type": "string",
              "enum": [
                "object",
                "array"
              ],
              "description": "\"object\" for 1 record, \"array\" for 1 entry per input item."
            },
            "fields": {
              "type": "array",
              "description": "The schema for 1 record.",
              "items": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string",
                    "description": "The JSON key."
                  },
                  "type": {
                    "type": "string",
                    "enum": [
                      "string",
                      "number",
                      "integer",
                      "boolean",
                      "array",
                      "object"
                    ],
                    "description": "The value's type."
                  },
                  "required": {
                    "type": "boolean",
                    "description": "Defaults to true. Set false for a field that may be absent."
                  },
                  "enum": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Restricts a string field to a fixed set of values."
                  },
                  "minimum": {
                    "type": "number",
                    "description": "Lower bound for a numeric field."
                  },
                  "maximum": {
                    "type": "number",
                    "description": "Upper bound for a numeric field."
                  },
                  "description": {
                    "type": "string",
                    "description": "Passed to the model as the field's description."
                  }
                },
                "required": [
                  "name",
                  "type"
                ]
              }
            },
            "count": {
              "type": "object",
              "description": "Bounds on the number of entries. Only read when shape is \"array\".",
              "properties": {
                "min": {
                  "type": "number"
                },
                "max": {
                  "type": "number"
                }
              }
            },
            "selection": {
              "type": "object",
              "description": "Use when you want the model to over-generate candidates and Rigor to sort, threshold, and cap them before the count bounds are checked.",
              "properties": {
                "scoreField": {
                  "type": "string"
                },
                "minScore": {
                  "type": "number"
                },
                "minCount": {
                  "type": "number"
                },
                "maxCount": {
                  "type": "number"
                }
              }
            }
          },
          "required": [
            "task_type",
            "shape",
            "fields"
          ]
        }
      }
    }
  },
  "required": [
    "task_description"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "ok": {
      "type": "boolean"
    },
    "plan": {
      "type": "object",
      "properties": {
        "workflow_id": {
          "type": "string"
        },
        "classification": {
          "type": "object",
          "properties": {
            "task_type": {
              "type": "string"
            },
            "value_class": {
              "type": "string"
            }
          }
        },
        "sequence": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "step": {
                "type": "number"
              },
              "name": {
                "type": "string"
              },
              "estimated_credits": {
                "type": "number"
              }
            }
          }
        },
        "cost": {
          "type": "object",
          "properties": {
            "credits": {
              "type": "number"
            },
            "usd": {
              "type": "number"
            },
            "range": {
              "type": "object"
            }
          }
        },
        "rigor_level": {
          "type": "string"
        },
        "allowed_modes": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Execution modes available for this plan beyond the standard multi-call default. Contains 'direct' when the plan is eligible for direct execution; empty array when it is not."
        },
        "alternatives": {
          "type": "object"
        },
        "info": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "warnings": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "code": {
                "type": "string"
              },
              "message": {
                "type": "string"
              },
              "suggestion": {
                "type": "string"
              }
            }
          }
        }
      }
    },
    "generated_title": {
      "type": "string"
    }
  }
}

Execute a structured workflow end-to-end. Call rigor_plan first (free) to preview the step sequence and cost estimate before committing credits. Classifies the task, selects the optimal tool sequence, and executes each step with the right LLM model. Returns a complete deliverable — solution designs, competitive analyses, governance documents, and more. Supports SSE streaming for real-time progress, webhook callback, or polling. For atomic work — classification, scoring, ranking, entity extraction, query parsing — set preferences.execution to 'direct' and declare preferences.output_contract to get validated JSON records from a single call, routed to the cheapest model that holds the schema.

{
  "type": "object",
  "properties": {
    "task_description": {
      "type": "string",
      "description": "Natural language description of the task. Be specific — include what you want produced, constraints, and context. Example: 'Design a caching layer for our API gateway with Redis integration.'"
    },
    "task_type": {
      "type": "string",
      "description": "Optional hint to bypass automatic classification. Passing it also removes the slowest classification tiers from the critical path, so send it whenever you know the shape. Multi-step deliverable types: solution_design, requirements_analysis, code_implementation, code_review, bug_fix, root_cause_analysis, incident_response, deployment_execution, competitive_scan, financial_analysis, research_task, documentation, governance_change, compliance_audit, data_security_assessment, performance_optimization, user_story_definition, implementation_prompt_generation. Atomic single-call types, which auto-select direct execution: tag, score, rerank, compose, extract_entities, parse_query, quick_research, quick_classification, quick_extraction, quick_scoring. Call GET /api/rigor/task-types for the full vocabulary with each type's shape."
    },
    "delivery": {
      "type": "object",
      "description": "Delivery method. Default: polling (MCP clients typically can't handle SSE).",
      "properties": {
        "method": {
          "type": "string",
          "description": "sse | webhook | polling. Default for MCP: polling."
        },
        "webhook_url": {
          "type": "string",
          "description": "Required if method is webhook. Must be HTTPS."
        }
      }
    },
    "preferences": {
      "type": "object",
      "description": "Optional workflow preferences.",
      "properties": {
        "rigor_level": {
          "type": "string",
          "description": "quick | standard (default) | thorough. Controls analysis depth and cost."
        },
        "max_budget_usd": {
          "type": "number",
          "description": "Maximum budget in USD."
        },
        "execution": {
          "type": "string",
          "enum": [
            "direct"
          ],
          "description": "Set to 'direct' to compose the plan's content frameworks into a single LLM call and route cost-first, using a per-task-type model floor that moves when a cheaper model earns the work. Research steps, process steps (classification-verify, review protocol, synthesis) and the quality review each remain separate calls, so this is not a one-call-per-workflow guarantee: for atomic task types, which have a single content framework, the call count matches standard execution and the saving is the model. Supplying output_contract replaces the quality-review call with deterministic validation, which is one fewer call. No intermediate outputs. Available at every tier. Auto-selected for atomic task types when no execution preference is given. Falls back to standard execution when combined with require_approval or interactive mode, or when the plan exceeds the composition size limit. Attachments and prior_workflow_id chaining are NOT applied — use standard execution for those."
        },
        "output_contract": {
          "type": "object",
          "description": "Only read when execution is \"direct\". Declares the JSON shape you want back, so the answer is generated against your schema and validated against it before return, instead of returned as prose you have to parse. A conforming run also skips the quality-review call, costing 1 LLM call rather than 2. The schema is closed: a record carrying an undeclared key is rejected exactly like one missing a required key.",
          "properties": {
            "task_type": {
              "type": "string",
              "description": "Your own label for the work. Echoed into telemetry. Not read as a framework name and does not change routing."
            },
            "shape": {
              "type": "string",
              "enum": [
                "object",
                "array"
              ],
              "description": "\"object\" for 1 record, \"array\" for 1 entry per input item."
            },
            "fields": {
              "type": "array",
              "description": "The schema for 1 record.",
              "items": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string",
                    "description": "The JSON key."
                  },
                  "type": {
                    "type": "string",
                    "enum": [
                      "string",
                      "number",
                      "integer",
                      "boolean",
                      "array",
                      "object"
                    ],
                    "description": "The value's type."
                  },
                  "required": {
                    "type": "boolean",
                    "description": "Defaults to true. Set false for a field that may be absent."
                  },
                  "enum": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Restricts a string field to a fixed set of values."
                  },
                  "minimum": {
                    "type": "number",
                    "description": "Lower bound for a numeric field."
                  },
                  "maximum": {
                    "type": "number",
                    "description": "Upper bound for a numeric field."
                  },
                  "description": {
                    "type": "string",
                    "description": "Passed to the model as the field's description."
                  }
                },
                "required": [
                  "name",
                  "type"
                ]
              }
            },
            "count": {
              "type": "object",
              "description": "Bounds on the number of entries. Only read when shape is \"array\".",
              "properties": {
                "min": {
                  "type": "number"
                },
                "max": {
                  "type": "number"
                }
              }
            },
            "selection": {
              "type": "object",
              "description": "Use when you want the model to over-generate candidates and Rigor to sort, threshold, and cap them before the count bounds are checked.",
              "properties": {
                "scoreField": {
                  "type": "string"
                },
                "minScore": {
                  "type": "number"
                },
                "minCount": {
                  "type": "number"
                },
                "maxCount": {
                  "type": "number"
                }
              }
            }
          },
          "required": [
            "task_type",
            "shape",
            "fields"
          ]
        }
      }
    },
    "context": {
      "type": "object",
      "description": "Additional context for the workflow.",
      "properties": {
        "additional_context": {
          "type": "string",
          "description": "Free-form context the workflow steps can reference."
        }
      }
    }
  },
  "required": [
    "task_description"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "ok": {
      "type": "boolean"
    },
    "workflow_id": {
      "type": "string"
    },
    "status": {
      "type": "string"
    },
    "task_type": {
      "type": "string"
    },
    "value_class": {
      "type": "string"
    },
    "estimated_credits": {
      "type": "number"
    },
    "poll_url": {
      "type": "string"
    },
    "delivery_mode": {
      "type": "string"
    },
    "available_modes": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "execution": {
      "type": "string",
      "description": "Present with value 'direct' when direct execution ran. Absent for standard multi-call execution."
    },
    "execution_fallback": {
      "type": "boolean",
      "description": "True when you explicitly requested direct execution and it could not be honoured — the workflow ran as standard multi-call instead. Never set for an auto-selected attempt, since you did not ask."
    }
  }
}

Check the status of a running or completed Rigor workflow. Returns progress, step results, and the full deliverable when complete. Use after rigor_execute with polling delivery to retrieve results.

{
  "type": "object",
  "properties": {
    "workflow_id": {
      "type": "string",
      "description": "The workflow ID returned by rigor_execute (format: wr_xxx)."
    }
  },
  "required": [
    "workflow_id"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "ok": {
      "type": "boolean"
    },
    "workflow": {
      "type": "object",
      "properties": {
        "workflow_id": {
          "type": "string"
        },
        "status": {
          "type": "string"
        },
        "task_type": {
          "type": "string"
        },
        "generated_title": {
          "type": "string"
        },
        "current_step": {
          "type": "number"
        },
        "total_steps": {
          "type": "number"
        },
        "actual_steps_executed": {
          "type": "number"
        },
        "completed_step_summaries": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "step": {
                "type": "number"
              },
              "tool": {
                "type": "string"
              },
              "framework": {
                "type": "string"
              },
              "summary": {
                "type": "string"
              },
              "model": {
                "type": "string"
              }
            }
          }
        },
        "quality_review": {
          "type": "object",
          "properties": {
            "score": {
              "type": "number"
            },
            "summary": {
              "type": "string"
            },
            "path_to_100": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        },
        "deliverable": {
          "type": "object",
          "properties": {
            "title": {
              "type": "string"
            },
            "sections": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "heading": {
                    "type": "string"
                  },
                  "content": {
                    "type": "string"
                  }
                }
              }
            }
          }
        },
        "credits_used": {
          "type": "number"
        },
        "created_at": {
          "type": "string"
        },
        "completed_at": {
          "type": "string"
        },
        "error": {
          "type": "string"
        }
      }
    }
  }
}

List and search Rigor workflows for your organization, with filtering and pagination. Returns status, progress, capacity usage, and available actions per workflow. Use to monitor workflow state, understand concurrent limit usage, identify stuck or completed workflows, and — via q — find prior work on a subject before commissioning it again. Pair a q hit with rigor_status to read that workflow's deliverable.

{
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "description": "Filter by status (comma-separated). Valid values: executing, step_executing, completed, failed, halted, pending_approval, cancelled. E.g. \"halted,failed,pending_approval\""
    },
    "task_type": {
      "type": "string",
      "description": "Filter by classified task type"
    },
    "q": {
      "type": "string",
      "description": "Search the workflow title and task description. Every whitespace-separated term must appear in one or the other, as a case-insensitive substring — so \"vector search postgres\" matches a task described as \"add vector search to an existing Postgres-backed SaaS app\". Substring matching, not full-text: there is no stemming and no ranking, so \"migrating\" does not match \"migration\". Max 200 characters and 8 terms; punctuation is treated as a separator and wildcards are not supported."
    },
    "folder_id": {
      "type": "string",
      "description": "Filter by folder ID. Pass \"unassigned\" for workflows in no folder"
    },
    "created_after": {
      "type": "string",
      "description": "ISO timestamp — only workflows created after this time"
    },
    "created_before": {
      "type": "string",
      "description": "ISO timestamp — only workflows created before this time"
    },
    "counts_toward_limit": {
      "type": "string",
      "enum": [
        "true",
        "false"
      ],
      "description": "Filter to workflows counting toward the concurrent limit"
    },
    "limit": {
      "type": "number",
      "description": "Page size (default 20, max 100)"
    },
    "cursor": {
      "type": "string",
      "description": "Pagination cursor (created_at timestamp from previous page)"
    }
  },
  "required": [],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "ok": {
      "type": "boolean"
    },
    "workflows": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "workflow_id": {
            "type": "string"
          },
          "status": {
            "type": "string"
          },
          "task_type": {
            "type": "string"
          },
          "generated_title": {
            "type": "string"
          },
          "task_excerpt": {
            "type": "string"
          },
          "current_step": {
            "type": "number"
          },
          "total_steps": {
            "type": "number"
          },
          "credits_charged": {
            "type": "number"
          },
          "created_at": {
            "type": "string"
          },
          "started_at": {
            "type": "string"
          },
          "completed_at": {
            "type": "string"
          },
          "history_locked": {
            "type": "boolean"
          },
          "counts_toward_limit": {
            "type": "boolean"
          },
          "available_actions": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        }
      }
    },
    "pagination": {
      "type": "object",
      "properties": {
        "cursor": {
          "type": "string"
        },
        "has_more": {
          "type": "boolean"
        },
        "total_count": {
          "type": "number"
        },
        "limit": {
          "type": "number"
        }
      }
    },
    "concurrent_summary": {
      "type": "object",
      "properties": {
        "active": {
          "type": "number"
        },
        "limit": {
          "type": "number"
        },
        "remaining": {
          "type": "number"
        }
      }
    },
    "credits_remaining": {
      "type": "number"
    }
  }
}