_ registry / mcp streamable-http · checked 40m ago

stewai

https://api.stewai.com

Registry code: cfb30cf3e321215e

api record

Call discover_stewai first. It explains authentication, scopes, the search-to-run and authoring journeys, result inspection, and recovery. Protected tools start secure browser sign-in automatically; never ask the user for a StewAI API key or password.

endpoint
https://api.stewai.com/mcp
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is stewai live?
Yes — it answered the hub's last check (checked 40m ago). It answered 100% of checks over the last 30 days.
Is stewai free to use?
Not measured yet.
What tools does stewai have?
14 tools: get_results, run_recipe, check_recipe_build, commit_recipe_build, get_recipe_build_activity, get_recipe_preview, get_run, run_recipe_acceptance, ….
Is stewai safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
100%

90 days 99.3%· all time 99.3%

latency
455ms

last good check

priced tools
0

of 14 tools

_ answered our checks, 90 days 279 checks · signed record
  • degraded → live
  • degraded → live
  • live → degraded· timeout after 20000ms
  • degraded → live
  • live → degraded· timeout after 20000ms
_ what it is for
used for
  • search published ai workflow recipes
  • run a recipe with inputs
  • build and check a private recipe
  • read results of a recipe run
takes → gives
text, data → data
tools
8 reads3 changes data3 effect unclear
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 14 tools
14 never probed 0 of 14 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • get_results reads unknown never probed

    Read declared outputs or a sanitized per-step trace from an owned run, including signed chunks for oversized steps. view=steps returns compact summaries, 10 per page by default and at most 20 (limit 1-20); follow next_cursor until it is null, pass detail=full for whole steps, or use view=step with step_id for one full step. Open recipes expose all authorized steps; closed recipes expose only input and output steps. Sensitive values stay redacted. Step reads are provisional until get_run reports a finished status. If outputs is empty, read view=steps; for a failed run, read the failed step and let the user decide. Present completed outputs as polished Markdown or text: lead with the useful outcome, add At a glance, supported strengths, impact-ordered findings, and concrete next steps; end with evidence, uncertainty, limitations, charged credits, and run ID. Render JSON as readable tables or bullets and HTML as content, not markup. Cross-check material claims against supplied source and cited evidence; describe unsupported or high-stakes conclusions as findings to verify. Say blocking only when the recipe explicitly classifies the item that way and evidence supports it. Keep diagnostics, safety ceilings, and platform plumbing out of the main answer; billing receipt issues stay quiet and never suppress ready results.

    mcp-tool

    {
      "type": "object",
      "required": [
        "run_id"
      ],
      "properties": {
        "view": {
          "enum": [
            "declared_outputs",
            "steps",
            "step",
            "step_chunk"
          ]
        },
        "limit": {
          "type": "integer",
          "maximum": 20,
          "minimum": 1,
          "description": "Steps per page for view=steps: default 10, at most 20."
        },
        "cursor": {
          "type": "string",
          "pattern": "^o:(?:0|[1-9][0-9]*)$",
          "maxLength": 8
        },
        "detail": {
          "enum": [
            "summary",
            "full"
          ],
          "description": "For view=steps: summary (default) lists each step's id, title, kind, status, timing and result type; full returns parameters, rendered input and result. view=step always returns the full step."
        },
        "run_id": {
          "type": "string",
          "pattern": "^[0-9A-Za-z]{26}$",
          "maxLength": 26,
          "minLength": 26
        },
        "step_id": {
          "type": "string",
          "maxLength": 128,
          "minLength": 1
        },
        "chunk_ref": {
          "type": "string",
          "maxLength": 2048,
          "minLength": 1
        }
      },
      "additionalProperties": false
    }
    arguments 51 lines
  • run_recipe unknown never probed

    Estimate or run a previewed public or account-authorized published recipe. dry_run foregrounds history (recent charges or median and p90), fees, balance, and can_start. safety_ceiling_credits is a pathological bound when available, not a quote or admission threshold; a null ceiling means provider search has no request-side query limit and does not block a run. estimated_credits and sufficient are deprecated compatibility aliases. can_start=true permits the approved real run even when the ceiling exceeds the wallet. can_start=false is reserved for a genuine admission blocker such as an unaffordable Marketplace fee. If credits run out during a run, it pauses and can be resumed after adding credits. On recipe_ref_expired, search or preview again and retry.

    mcp-tool

    {
      "type": "object",
      "required": [
        "recipe_ref",
        "inputs",
        "idempotency_key"
      ],
      "properties": {
        "inputs": {
          "type": "object",
          "maxProperties": 50,
          "propertyNames": {
            "pattern": "^input_[1-9][0-9]*$"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "dry_run": {
          "type": "boolean"
        },
        "recipe_ref": {
          "type": "string",
          "maxLength": 32768
        },
        "idempotency_key": {
          "type": "string",
          "pattern": "^[\\x20-\\x7E]+$",
          "maxLength": 200,
          "minLength": 1
        }
      },
      "additionalProperties": false
    }
    arguments 34 lines
  • check_recipe_build reads unknown never probed

    Run free deterministic lint, render, policy, and compiler checks. Omit fixtures for the normal structural check; a supplied fixture probe must also provide every referenced upstream dependency value.

    mcp-tool

    {
      "type": "object",
      "required": [
        "build_ref"
      ],
      "properties": {
        "fixtures": {
          "type": "object",
          "maxProperties": 20,
          "additionalProperties": {
            "oneOf": [
              {
                "type": "string",
                "maxLength": 32768
              },
              {
                "type": "object"
              },
              {
                "type": "array"
              },
              {
                "type": "number"
              },
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "build_ref": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        },
        "render_only": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    }
    arguments 44 lines
  • commit_recipe_build changes data unknown never probed

    Preflight and privately publish only the exact fully qualified recipe revision. A successful commit returns a private editor URL and, when current run access permits it, a recipe_ref. Preview that reference before any dry run: authoring contract handles and node IDs are not the positional input_N run handles. The recipe stays private, unlisted, and unreviewed; commit never lists, prices, or publishes it in the public marketplace.

    mcp-tool

    {
      "type": "object",
      "required": [
        "build_ref",
        "revision",
        "mode",
        "idempotency_key"
      ],
      "properties": {
        "mode": {
          "enum": [
            "preflight",
            "commit"
          ]
        },
        "revision": {
          "type": "string",
          "pattern": "^[0-9a-f]{64}$",
          "maxLength": 64
        },
        "build_ref": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        },
        "idempotency_key": {
          "type": "string",
          "pattern": "^[\\x20-\\x7e]+$",
          "maxLength": 200,
          "minLength": 1
        },
        "commit_capability": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1,
          "description": "Required for commit; omit for preflight."
        }
      },
      "additionalProperties": false
    }
    arguments 40 lines
  • get_recipe_build_activity reads unknown never probed

    Poll a review or acceptance batch through a bounded, disclosure-safe view.

    mcp-tool

    {
      "type": "object",
      "required": [
        "activity_ref"
      ],
      "properties": {
        "cursor": {
          "type": "string",
          "maxLength": 512
        },
        "section": {
          "enum": [
            "summary",
            "nodes",
            "assertions",
            "coverage",
            "billing"
          ]
        },
        "activity_ref": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        }
      },
      "additionalProperties": false
    }
    arguments 27 lines
  • get_recipe_preview reads unknown never probed

    Inspect a safe summary with bounded method and limitations excerpts, output-contract state, and evidence context. For complete authorized published details and executable contracts, use view=details. Concatenate content fragments in offset order per section; decode JSON sections after completion. Use next_cursor with the same recipe_ref until null. Opaque internals remain withheld.

    mcp-tool

    {
      "type": "object",
      "required": [
        "recipe_ref"
      ],
      "properties": {
        "view": {
          "enum": [
            "summary",
            "details"
          ]
        },
        "cursor": {
          "type": "string",
          "maxLength": 2000
        },
        "recipe_ref": {
          "type": "string",
          "maxLength": 32768
        }
      },
      "additionalProperties": false
    }
    arguments 23 lines
  • get_run reads unknown never probed

    Read an owned run, view=history to resume normal runs (recipe_ref/status/cursor/limit), or view=diagnostics for its settled UI receipt. Default status requires run_id and includes live progress: updated_at is the run record time, progress.last_step_activity_at is the latest step activity. A blocked run paused for credits reports credit_pause.

    mcp-tool

    {
      "type": "object",
      "required": [],
      "properties": {
        "view": {
          "enum": [
            "status",
            "history",
            "diagnostics"
          ]
        },
        "limit": {
          "type": "integer",
          "maximum": 20,
          "minimum": 1
        },
        "cursor": {
          "type": "string",
          "maxLength": 1024
        },
        "run_id": {
          "type": "string",
          "pattern": "^[0-9A-Za-z]{26}$",
          "maxLength": 26,
          "minLength": 26
        },
        "status": {
          "enum": [
            "queued",
            "running",
            "done",
            "failed",
            "cancelled",
            "blocked"
          ]
        },
        "recipe_ref": {
          "type": "string",
          "maxLength": 4096
        }
      },
      "additionalProperties": false
    }
    arguments 43 lines
  • run_recipe_acceptance unknown never probed

    Quote or run selected or complete behavioral acceptance cases for an exact private draft revision. Quotes explain enforced input bounds, output caps and retry allowances in acceptance_cost. Preserve representative fixtures and assertions; remove unnecessary model stages rather than weakening tests to lower a quote. Paid work requires an approved budget. A full run that needs user approval returns supervised_required before any case, reservation, or external effect; first bind every returned required resource with update_recipe_build bind_resource, then open action_url for user approval, and finally resume the same activity with update_recipe_build resume_activity.

    mcp-tool

    {
      "type": "object",
      "required": [
        "build_ref",
        "revision",
        "mode",
        "idempotency_key"
      ],
      "properties": {
        "mode": {
          "enum": [
            "quote",
            "selected_cases",
            "full"
          ]
        },
        "case_ids": {
          "type": "array",
          "items": {
            "type": "string",
            "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$",
            "maxLength": 64
          },
          "maxItems": 50,
          "minItems": 1,
          "description": "Required for selected_cases, optional for quote, forbidden for full.",
          "uniqueItems": true
        },
        "revision": {
          "type": "string",
          "pattern": "^[0-9a-f]{64}$",
          "maxLength": 64
        },
        "build_ref": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        },
        "idempotency_key": {
          "type": "string",
          "pattern": "^[\\x20-\\x7e]+$",
          "maxLength": 200,
          "minLength": 1
        }
      },
      "additionalProperties": false
    }
    arguments 47 lines
  • start_recipe_build changes data unknown never probed

    Create a private recipe build from a bounded intent and declared contract. Recipe inputs are strings: use type:string, positive maxLength, and only minLength:1 on required inputs. Richer input constraints must be handled in recipe logic and tested, not claimed as enforced by the input node. The response returns the stored contracts when they fit the bounded result; the archetype bundle is optional guidance, not the build contract. Optionally provide source_recipe_ref to adapt an owned recipe or a fully viewable public-open recipe into a new private draft.

    mcp-tool

    {
      "type": "object",
      "required": [
        "name",
        "intent",
        "input_contract",
        "output_contract",
        "capabilities",
        "risk_domains",
        "quality_profile",
        "research_policy",
        "idempotency_key"
      ],
      "properties": {
        "name": {
          "type": "string",
          "maxLength": 200,
          "minLength": 1
        },
        "intent": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        },
        "capabilities": {
          "type": "array",
          "items": {
            "enum": [
              "research",
              "extract",
              "classify",
              "summarize",
              "transform",
              "score",
              "compare",
              "route",
              "render",
              "reconcile"
            ]
          },
          "maxItems": 20,
          "uniqueItems": true
        },
        "risk_domains": {
          "type": "array",
          "items": {
            "enum": [
              "general",
              "legal",
              "financial",
              "medical",
              "employment",
              "education",
              "credit",
              "insurance",
              "public_services",
              "safety",
              "privacy",
              "security"
            ]
          },
          "maxItems": 10,
          "uniqueItems": true
        },
        "input_contract": {
          "type": "object",
          "required": [
            "fields"
          ],
          "properties": {
            "fields": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "handle",
                  "label",
                  "description",
                  "required",
                  "schema"
                ],
                "properties": {
                  "label": {
                    "type": "string",
                    "maxLength": 120,
                    "minLength": 1
                  },
                  "handle": {
                    "type": "string",
                    "pattern": "^[a-z][a-z0-9_]{0,63}$",
                    "maxLength": 64
                  },
                  "schema": {
                    "type": "object",
                    "maxProperties": 100
                  },
                  "required": {
                    "type": "boolean"
                  },
                  "description": {
                    "type": "string",
                    "maxLength": 500
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 20
            }
          },
          "additionalProperties": false
        },
        "idempotency_key": {
          "type": "string",
          "pattern": "^[\\x20-\\x7e]+$",
          "maxLength": 200,
          "minLength": 1
        },
        "output_contract": {
          "type": "object",
          "required": [
            "fields"
          ],
          "properties": {
            "fields": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "handle",
                  "label",
                  "description",
                  "required",
                  "schema"
                ],
                "properties": {
                  "label": {
                    "type": "string",
                    "maxLength": 120,
                    "minLength": 1
                  },
                  "handle": {
                    "type": "string",
                    "pattern": "^[a-z][a-z0-9_]{0,63}$",
                    "maxLength": 64
                  },
                  "schema": {
                    "type": "object",
                    "maxProperties": 100
                  },
                  "required": {
                    "const": true
                  },
                  "description": {
                    "type": "string",
                    "maxLength": 500
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 20
            }
          },
          "additionalProperties": false
        },
        "quality_profile": {
          "enum": [
            "balanced",
            "rigorous"
          ]
        },
        "research_policy": {
          "enum": [
            "forbidden",
            "allowed",
            "required"
          ]
        },
        "source_recipe_ref": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        }
      },
      "additionalProperties": false
    }
    arguments 185 lines
  • update_recipe_build changes data unknown never probed

    Apply bounded optimistic changes to an owned private recipe build. After an uncertain response, inspect the build and replay the identical request with the same idempotency key; a new key duplicates the work. Use only the exact op names and payload keys in inputSchema: set_metadata takes metadata, upsert_schema takes schema_id and schema, and acceptance uses set_acceptance_cases with suite. Never invent set_schema or set_acceptance_suite. If an op appears unknown, read get_recipe_build view='authoring_schema', schema_name='update_recipe_build'; read schema_name='acceptance_suite' for the complete suite shape and every assertion operator with its required, allowed and forbidden fields. Do not guess them. Use set_contracts to replace the declared executable input and output contracts; this changes the revision and invalidates qualification. For a supervised acceptance handoff, use bind_resource only to approve an exact selector already frozen in the draft, then resume_activity or cancel_activity with the returned opaque handoff and activity references. Each handoff control operation must be the only op in its request. An acceptance suite is {version:1,cases:[{case_id,label,kind,fixtures,assertions}]}. Each fixture is {target,content_type,value}. A minimal assertion is {assertion_id:'result_exists',type:'scalar',operator:'exists',path:'/result'}. JSON Pointer paths start with '/'. A metamorphic case also requires pair_with naming another case. Use a paired assertion such as {assertion_id:'stable',type:'paired',operator:'fields_unchanged',path:'',pair_case_id:'base',fields:['/summary']}; pair_case_id is not valid on a scalar assertion. Client transport recommendation, not a server limit: keep serialized tool arguments below 32 KiB including JSON escaping and the request envelope. For larger spec, suite, or research content use begin_chunk, ordered append_chunk (seq starts at 0), then commit_chunk. Keep each complete append request below 12 KiB; split text further after measuring escaped JSON bytes. Hash the exact assembled UTF-8 text with SHA-256. Begin/append do not change the revision; commit changes it once. After an uncertain response, inspect the build and replay the identical request with the same idempotency key; do not create duplicate work with a new key.

    mcp-tool

    {
      "type": "object",
      "required": [
        "build_ref",
        "revision",
        "idempotency_key",
        "ops"
      ],
      "properties": {
        "ops": {
          "type": "array",
          "items": {
            "oneOf": [
              {
                "type": "object",
                "required": [
                  "op",
                  "spec"
                ],
                "properties": {
                  "op": {
                    "const": "replace_spec"
                  },
                  "spec": {
                    "type": "object"
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "input_contract",
                  "output_contract"
                ],
                "properties": {
                  "op": {
                    "const": "set_contracts"
                  },
                  "input_contract": {
                    "type": "object",
                    "required": [
                      "fields"
                    ],
                    "properties": {
                      "fields": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "handle",
                            "label",
                            "description",
                            "required",
                            "schema"
                          ],
                          "properties": {
                            "label": {
                              "type": "string",
                              "maxLength": 120,
                              "minLength": 1
                            },
                            "handle": {
                              "type": "string",
                              "pattern": "^[a-z][a-z0-9_]{0,63}$",
                              "maxLength": 64
                            },
                            "schema": {
                              "type": "object",
                              "maxProperties": 100
                            },
                            "required": {
                              "type": "boolean"
                            },
                            "description": {
                              "type": "string",
                              "maxLength": 500
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 20
                      }
                    },
                    "additionalProperties": false
                  },
                  "output_contract": {
                    "type": "object",
                    "required": [
                      "fields"
                    ],
                    "properties": {
                      "fields": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "handle",
                            "label",
                            "description",
                            "required",
                            "schema"
                          ],
                          "properties": {
                            "label": {
                              "type": "string",
                              "maxLength": 120,
                              "minLength": 1
                            },
                            "handle": {
                              "type": "string",
                              "pattern": "^[a-z][a-z0-9_]{0,63}$",
                              "maxLength": 64
                            },
                            "schema": {
                              "type": "object",
                              "maxProperties": 100
                            },
                            "required": {
                              "const": true
                            },
                            "description": {
                              "type": "string",
                              "maxLength": 500
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 20
                      }
                    },
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "metadata"
                ],
                "properties": {
                  "op": {
                    "const": "set_metadata"
                  },
                  "metadata": {
                    "type": "object",
                    "required": [],
                    "properties": {
                      "$ui": {
                        "type": "object"
                      },
                      "name": {
                        "type": "string",
                        "maxLength": 200,
                        "minLength": 1
                      },
                      "$comment": {
                        "oneOf": [
                          {
                            "type": "string",
                            "maxLength": 4096
                          },
                          {
                            "type": "object"
                          }
                        ]
                      },
                      "description": {
                        "type": "string",
                        "maxLength": 4096
                      }
                    },
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "node"
                ],
                "properties": {
                  "op": {
                    "const": "upsert_node"
                  },
                  "node": {
                    "type": "object"
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "node_id"
                ],
                "properties": {
                  "op": {
                    "const": "remove_node"
                  },
                  "node_id": {
                    "type": "string",
                    "pattern": "^[a-z][a-z0-9_]{0,63}$",
                    "maxLength": 64
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "node_ids"
                ],
                "properties": {
                  "op": {
                    "const": "reorder_nodes"
                  },
                  "node_ids": {
                    "type": "array",
                    "items": {
                      "type": "string",
                      "pattern": "^[a-z][a-z0-9_]{0,63}$",
                      "maxLength": 64
                    },
                    "maxItems": 200,
                    "uniqueItems": true
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "schema_id",
                  "schema"
                ],
                "properties": {
                  "op": {
                    "const": "upsert_schema"
                  },
                  "schema": {
                    "type": "object",
                    "maxProperties": 100
                  },
                  "schema_id": {
                    "type": "string",
                    "pattern": "^[a-z][a-z0-9_]{0,63}$",
                    "maxLength": 64
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "schema_id"
                ],
                "properties": {
                  "op": {
                    "const": "remove_schema"
                  },
                  "schema_id": {
                    "type": "string",
                    "pattern": "^[a-z][a-z0-9_]{0,63}$",
                    "maxLength": 64
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "suite"
                ],
                "properties": {
                  "op": {
                    "const": "set_acceptance_cases"
                  },
                  "suite": {
                    "type": "object",
                    "required": [
                      "version",
                      "cases"
                    ],
                    "properties": {
                      "cases": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "required": [
                            "case_id",
                            "label",
                            "kind",
                            "fixtures",
                            "assertions"
                          ],
                          "properties": {
                            "kind": {
                              "enum": [
                                "adversarial",
                                "empty",
                                "injection",
                                "malformed",
                                "metamorphic",
                                "normal"
                              ]
                            },
                            "label": {
                              "type": "string",
                              "maxLength": 120,
                              "minLength": 1
                            },
                            "case_id": {
                              "type": "string",
                              "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
                            },
                            "fixtures": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "required": [
                                  "target",
                                  "content_type",
                                  "value"
                                ],
                                "properties": {
                                  "value": {
                                    "type": "string",
                                    "maxLength": 32768
                                  },
                                  "target": {
                                    "type": "string",
                                    "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
                                  },
                                  "content_type": {
                                    "enum": [
                                      "application/json",
                                      "text/plain"
                                    ]
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 20
                            },
                            "pair_with": {
                              "type": "string",
                              "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
                            },
                            "assertions": {
                              "type": "array",
                              "items": {
                                "type": "object",
                                "allOf": [
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "classification"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "coverage_at_least",
                                            "join_by_id",
                                            "metric_at_least",
                                            "no_critical_false_negative"
                                          ]
                                        }
                                      }
                                    }
                                  },
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "collection"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "any",
                                            "count_equals",
                                            "covers_records",
                                            "every",
                                            "unique_by"
                                          ]
                                        }
                                      }
                                    }
                                  },
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "coverage"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "branch_covered",
                                            "enum_covered"
                                          ]
                                        }
                                      }
                                    }
                                  },
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "html"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "escaped",
                                            "well_formed"
                                          ]
                                        }
                                      }
                                    }
                                  },
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "paired"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "fields_unchanged",
                                            "mirror_changes",
                                            "permutation_invariant",
                                            "sensitivity_stable"
                                          ]
                                        }
                                      }
                                    }
                                  },
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "quote_present"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "quote_present_in"
                                          ]
                                        }
                                      }
                                    }
                                  },
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "reconcile"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "equals_computed",
                                            "within_tolerance"
                                          ]
                                        }
                                      }
                                    }
                                  },
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "scalar"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "between",
                                            "contains",
                                            "equals",
                                            "exists",
                                            "glob",
                                            "in_set",
                                            "not_in_set",
                                            "type_is"
                                          ]
                                        }
                                      }
                                    }
                                  },
                                  {
                                    "if": {
                                      "required": [
                                        "type"
                                      ],
                                      "properties": {
                                        "type": {
                                          "const": "security"
                                        }
                                      }
                                    },
                                    "then": {
                                      "properties": {
                                        "operator": {
                                          "enum": [
                                            "answer_not_leaked",
                                            "injection_resisted"
                                          ]
                                        }
                                      }
                                    }
                                  }
                                ],
                                "required": [
                                  "assertion_id",
                                  "type",
                                  "operator"
                                ],
                                "properties": {
                                  "left": {
                                    "$ref": "#/definitions/expression"
                                  },
                                  "path": {
                                    "type": "string",
                                    "maxLength": 256
                                  },
                                  "type": {
                                    "enum": [
                                      "classification",
                                      "collection",
                                      "coverage",
                                      "html",
                                      "paired",
                                      "quote_present",
                                      "reconcile",
                                      "scalar",
                                      "security"
                                    ]
                                  },
                                  "right": {
                                    "$ref": "#/definitions/expression"
                                  },
                                  "fields": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 256
                                    },
                                    "maxItems": 50
                                  },
                                  "metric": {
                                    "enum": [
                                      "accuracy",
                                      "macro_precision",
                                      "macro_recall",
                                      "macro_f1"
                                    ]
                                  },
                                  "values": {
                                    "type": "array",
                                    "maxItems": 200
                                  },
                                  "maximum": {
                                    "type": "number"
                                  },
                                  "message": {
                                    "type": "string",
                                    "maxLength": 200,
                                    "minLength": 1
                                  },
                                  "minimum": {
                                    "type": "number"
                                  },
                                  "pattern": {
                                    "type": "string",
                                    "maxLength": 256,
                                    "minLength": 1
                                  },
                                  "expected": {},
                                  "key_path": {
                                    "type": "string",
                                    "maxLength": 256
                                  },
                                  "mappings": {
                                    "type": "array",
                                    "items": {
                                      "$ref": "#/definitions/field_mapping"
                                    },
                                    "maxItems": 50
                                  },
                                  "operator": {
                                    "enum": [
                                      "answer_not_leaked",
                                      "any",
                                      "between",
                                      "branch_covered",
                                      "contains",
                                      "count_equals",
                                      "coverage_at_least",
                                      "covers_records",
                                      "enum_covered",
                                      "equals",
                                      "equals_computed",
                                      "escaped",
                                      "every",
                                      "exists",
                                      "fields_unchanged",
                                      "glob",
                                      "in_set",
                                      "injection_resisted",
                                      "join_by_id",
                                      "metric_at_least",
                                      "mirror_changes",
                                      "no_critical_false_negative",
                                      "not_in_set",
                                      "permutation_invariant",
                                      "quote_present_in",
                                      "sensitivity_stable",
                                      "type_is",
                                      "unique_by",
                                      "well_formed",
                                      "within_tolerance"
                                    ]
                                  },
                                  "pair_path": {
                                    "type": "string",
                                    "maxLength": 256
                                  },
                                  "predicate": {
                                    "$ref": "#/definitions/scalar_predicate"
                                  },
                                  "threshold": {
                                    "type": "number",
                                    "maximum": 1,
                                    "minimum": 0
                                  },
                                  "tolerance": {
                                    "type": "number",
                                    "minimum": 0
                                  },
                                  "assertion_id": {
                                    "type": "string",
                                    "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
                                  },
                                  "pair_case_id": {
                                    "type": "string",
                                    "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
                                  },
                                  "actual_id_path": {
                                    "type": "string",
                                    "maxLength": 256
                                  },
                                  "fixture_target": {
                                    "type": "string",
                                    "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
                                  },
                                  "critical_labels": {
                                    "type": "array",
                                    "items": {
                                      "type": "string"
                                    },
                                    "maxItems": 50
                                  },
                                  "fixture_targets": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
                                    },
                                    "maxItems": 20
                                  },
                                  "required_values": {
                                    "type": "array",
                                    "maxItems": 200
                                  },
                                  "expected_id_path": {
                                    "type": "string",
                                    "maxLength": 256
                                  },
                                  "expected_records": {
                                    "type": "array",
                                    "maxItems": 200
                                  },
                                  "actual_label_path": {
                                    "type": "string",
                                    "maxLength": 256
                                  },
                                  "forbidden_literals": {
                                    "type": "array",
                                    "items": {
                                      "type": "string",
                                      "maxLength": 500
                                    },
                                    "maxItems": 50
                                  },
                                  "accepted_limitation": {
                                    "type": "string",
                                    "maxLength": 500,
                                    "minLength": 20,
                                    "description": "User-approved semantic limitation and reason for accepting it for supervised private use. Never invent approval. Failure remains visible but does not block this case."
                                  },
                                  "expected_label_path": {
                                    "type": "string",
                                    "maxLength": 256
                                  }
                                },
                                "additionalProperties": false
                              },
                              "maxItems": 50,
                              "minItems": 1
                            },
                            "expect_branch": {
                              "type": "object",
                              "required": [
                                "path",
                                "value"
                              ],
                              "properties": {
                                "path": {
                                  "type": "string",
                                  "maxLength": 256
                                },
                                "value": {
                                  "type": "string",
                                  "maxLength": 64,
                                  "minLength": 1
                                }
                              },
                              "additionalProperties": false
                            }
                          },
                          "additionalProperties": false
                        },
                        "maxItems": 50,
                        "minItems": 1
                      },
                      "version": {
                        "const": 1
                      }
                    },
                    "additionalProperties": false
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "evidence"
                ],
                "properties": {
                  "op": {
                    "const": "record_research"
                  },
                  "evidence": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "url",
                        "title",
                        "retrieved_at",
                        "supported_claim",
                        "applicability"
                      ],
                      "properties": {
                        "url": {
                          "type": "string",
                          "maxLength": 512,
                          "minLength": 1
                        },
                        "title": {
                          "type": "string",
                          "maxLength": 200,
                          "minLength": 1
                        },
                        "retrieved_at": {
                          "type": "string",
                          "maxLength": 64,
                          "minLength": 1
                        },
                        "applicability": {
                          "type": "string",
                          "maxLength": 1000,
                          "minLength": 1
                        },
                        "supported_claim": {
                          "type": "string",
                          "maxLength": 1000,
                          "minLength": 1
                        }
                      },
                      "additionalProperties": false
                    },
                    "maxItems": 20
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "budget_capability"
                ],
                "properties": {
                  "op": {
                    "const": "set_budget"
                  },
                  "budget_capability": {
                    "type": "string",
                    "maxLength": 4096,
                    "minLength": 1
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "handoff_ref",
                  "requirement_id"
                ],
                "properties": {
                  "op": {
                    "const": "bind_resource"
                  },
                  "handoff_ref": {
                    "type": "string",
                    "maxLength": 4096,
                    "minLength": 1
                  },
                  "requirement_id": {
                    "type": "string",
                    "pattern": "^[0-9a-f]{32}$"
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "handoff_ref",
                  "activity_ref"
                ],
                "properties": {
                  "op": {
                    "const": "resume_activity"
                  },
                  "handoff_ref": {
                    "type": "string",
                    "maxLength": 4096,
                    "minLength": 1
                  },
                  "activity_ref": {
                    "type": "string",
                    "maxLength": 4096,
                    "minLength": 1
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "handoff_ref",
                  "activity_ref"
                ],
                "properties": {
                  "op": {
                    "const": "cancel_activity"
                  },
                  "handoff_ref": {
                    "type": "string",
                    "maxLength": 4096,
                    "minLength": 1
                  },
                  "activity_ref": {
                    "type": "string",
                    "maxLength": 4096,
                    "minLength": 1
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op"
                ],
                "properties": {
                  "op": {
                    "const": "restore"
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "chunk_id"
                ],
                "properties": {
                  "op": {
                    "const": "begin_chunk"
                  },
                  "chunk_id": {
                    "type": "string",
                    "pattern": "^[a-z][a-z0-9_]{0,63}$",
                    "maxLength": 64
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "chunk_id",
                  "seq",
                  "text"
                ],
                "properties": {
                  "op": {
                    "const": "append_chunk"
                  },
                  "seq": {
                    "type": "integer",
                    "maximum": 32767,
                    "minimum": 0
                  },
                  "text": {
                    "type": "string",
                    "maxLength": 49152,
                    "minLength": 1
                  },
                  "chunk_id": {
                    "type": "string",
                    "pattern": "^[a-z][a-z0-9_]{0,63}$",
                    "maxLength": 64
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "chunk_id",
                  "sha256",
                  "target"
                ],
                "properties": {
                  "op": {
                    "const": "commit_chunk"
                  },
                  "sha256": {
                    "type": "string",
                    "pattern": "^[0-9a-f]{64}$",
                    "maxLength": 64
                  },
                  "target": {
                    "enum": [
                      "replace_spec",
                      "set_acceptance_cases",
                      "record_research"
                    ]
                  },
                  "chunk_id": {
                    "type": "string",
                    "pattern": "^[a-z][a-z0-9_]{0,63}$",
                    "maxLength": 64
                  }
                },
                "additionalProperties": false
              }
            ]
          },
          "maxItems": 25,
          "minItems": 1
        },
        "revision": {
          "type": "string",
          "pattern": "^[0-9a-f]{64}$",
          "maxLength": 64
        },
        "build_ref": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        },
        "idempotency_key": {
          "type": "string",
          "pattern": "^[\\x20-\\x7e]+$",
          "maxLength": 200,
          "minLength": 1
        }
      },
      "definitions": {
        "expression": {
          "oneOf": [
            {
              "type": "object",
              "required": [
                "kind",
                "value"
              ],
              "properties": {
                "kind": {
                  "const": "literal"
                },
                "value": {
                  "type": "number"
                }
              },
              "additionalProperties": false
            },
            {
              "type": "object",
              "required": [
                "kind",
                "path"
              ],
              "properties": {
                "kind": {
                  "const": "path"
                },
                "path": {
                  "type": "string",
                  "maxLength": 256
                }
              },
              "additionalProperties": false
            },
            {
              "type": "object",
              "required": [
                "kind",
                "case_id",
                "path"
              ],
              "properties": {
                "kind": {
                  "const": "case_path"
                },
                "path": {
                  "type": "string",
                  "maxLength": 256
                },
                "case_id": {
                  "type": "string",
                  "pattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
                }
              },
              "additionalProperties": false
            },
            {
              "type": "object",
              "required": [
                "kind",
                "expression"
              ],
              "properties": {
                "kind": {
                  "enum": [
                    "count",
                    "sum"
                  ]
                },
                "expression": {
                  "$ref": "#/definitions/expression"
                }
              },
              "additionalProperties": false
            },
            {
              "type": "object",
              "required": [
                "kind",
                "left",
                "right"
              ],
              "properties": {
                "kind": {
                  "enum": [
                    "add",
                    "subtract",
                    "multiply",
                    "divide"
                  ]
                },
                "left": {
                  "$ref": "#/definitions/expression"
                },
                "right": {
                  "$ref": "#/definitions/expression"
                }
              },
              "additionalProperties": false
            }
          ]
        },
        "field_mapping": {
          "type": "object",
          "required": [
            "path",
            "pair_path"
          ],
          "properties": {
            "path": {
              "type": "string",
              "maxLength": 256
            },
            "pair_path": {
              "type": "string",
              "maxLength": 256
            }
          },
          "additionalProperties": false
        },
        "scalar_predicate": {
          "type": "object",
          "required": [
            "operator"
          ],
          "properties": {
            "path": {
              "type": "string",
              "maxLength": 256
            },
            "values": {
              "type": "array",
              "maxItems": 200
            },
            "maximum": {
              "type": "number"
            },
            "minimum": {
              "type": "number"
            },
            "pattern": {
              "type": "string",
              "maxLength": 256,
              "minLength": 1
            },
            "expected": {},
            "operator": {
              "enum": [
                "between",
                "contains",
                "equals",
                "exists",
                "glob",
                "in_set",
                "not_in_set",
                "type_is"
              ]
            }
          },
          "additionalProperties": false
        }
      },
      "description": "Client transport recommendation, not a server limit: keep serialized tool arguments below 32 KiB including JSON escaping and the request envelope. For larger spec, suite, or research content use begin_chunk, ordered append_chunk (seq starts at 0), then commit_chunk. Keep each complete append request below 12 KiB; split text further after measuring escaped JSON bytes. Hash the exact assembled UTF-8 text with SHA-256. Begin/append do not change the revision; commit changes it once. After an uncertain response, inspect the build and replay the identical request with the same idempotency key; do not create duplicate work with a new key.",
      "additionalProperties": false
    }
    arguments 1232 lines
  • get_recipe_build reads unknown never probed

    List or inspect only the authenticated creator's private recipe builds. To list builds omit both build_ref and view; limit/cursor paginate that list. With or without build_ref, use view='authoring_schema' and schema_name='update_recipe_build', 'acceptance_suite', or 'start_recipe_build' to read the complete executable JSON Schema when a client hides nested operation or assertion fields. Large acceptance_plan reads return data.suite_page JSON fragments: append content in offset order, pass data.next_cursor as cursor until null, then parse the complete suite and verify its sha256. Small plans retain data.suite. Use view='capabilities' to discover the complete 24-handler authoring and automatic-acceptance capability catalog.

    mcp-tool

    {
      "type": "object",
      "required": [],
      "properties": {
        "view": {
          "enum": [
            "summary",
            "contracts",
            "node_inventory",
            "node",
            "schemas",
            "capabilities",
            "capabilities_index",
            "capability",
            "models",
            "research",
            "acceptance_plan",
            "activity",
            "handoffs",
            "resources",
            "guidance",
            "authoring_schema"
          ]
        },
        "limit": {
          "type": "integer",
          "maximum": 25,
          "minimum": 1
        },
        "cursor": {
          "type": "string",
          "maxLength": 512
        },
        "node_id": {
          "type": "string",
          "pattern": "^[a-z][a-z0-9_]{0,63}$",
          "maxLength": 64
        },
        "model_id": {
          "type": "string",
          "maxLength": 200
        },
        "build_ref": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        },
        "node_type": {
          "type": "string",
          "maxLength": 64
        },
        "schema_name": {
          "enum": [
            "update_recipe_build",
            "acceptance_suite",
            "start_recipe_build"
          ]
        },
        "include_archived": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    }
    arguments 64 lines
  • review_recipe_build unknown never probed

    Quote or run a bounded semantic quality review of the exact private draft revision.

    mcp-tool

    {
      "type": "object",
      "required": [
        "build_ref",
        "revision",
        "mode",
        "idempotency_key"
      ],
      "properties": {
        "mode": {
          "enum": [
            "quote",
            "execute"
          ]
        },
        "revision": {
          "type": "string",
          "pattern": "^[0-9a-f]{64}$",
          "maxLength": 64
        },
        "build_ref": {
          "type": "string",
          "maxLength": 4096,
          "minLength": 1
        },
        "idempotency_key": {
          "type": "string",
          "pattern": "^[\\x20-\\x7e]+$",
          "maxLength": 200,
          "minLength": 1
        }
      },
      "additionalProperties": false
    }
    arguments 34 lines
  • search_recipes reads unknown never probed

    Find safe public recipes and published recipes available to the current account. results are direct fits (exact or strong); related_results are adjacent recipes, not direct fits. Each row states its output contract, past-run cost history and, for reviewed public recipes, that safety review is not output-quality validation. required_inputs and required_outputs match exact handles or normalized labels, never meanings. When paging.has_more is true, repeat the identical call with cursor=next_cursor.

    mcp-tool

    {
      "type": "object",
      "required": [
        "query"
      ],
      "properties": {
        "query": {
          "type": "string",
          "maxLength": 2000,
          "minLength": 3,
          "description": "At least 3 non-padding characters, up to 2000. Name the task in a few words; add constraints as required_inputs or required_outputs; follow next_cursor when results are cut."
        },
        "cursor": {
          "type": "string",
          "pattern": "^[0-9]{1,2}$",
          "description": "next_cursor from the previous page of the identical query and filters. Omit for the first page."
        },
        "sources": {
          "type": "array",
          "items": {
            "enum": [
              "public",
              "owned",
              "organization",
              "shared"
            ]
          },
          "maxItems": 4,
          "minItems": 1,
          "description": "When omitted, search public recipes and any library lanes authorized by this connection. Explicit private lanes require recipes:read permission.",
          "uniqueItems": true
        },
        "runnable_only": {
          "type": "boolean"
        },
        "required_inputs": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 100,
            "minLength": 1
          },
          "maxItems": 20,
          "description": "Exact normalized handle/label matching, not semantic meaning; inspect filter_diagnostics for available labels.",
          "uniqueItems": true
        },
        "required_outputs": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 100,
            "minLength": 1
          },
          "maxItems": 20,
          "description": "Exact normalized handle/label matching, not semantic meaning; filters are never weakened automatically.",
          "uniqueItems": true
        }
      },
      "additionalProperties": false
    }
    arguments 60 lines
  • discover_stewai reads unknown never probed

    Learn how any MCP agent can authenticate, discover, preview, run, author, qualify, commit, inspect, and recover StewAI recipes. Call this first.

    mcp-tool

    {
      "type": "object",
      "properties": {},
      "additionalProperties": false
    }
    arguments 5 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id cfb30cf3e321215e.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/cfb30cf3e321215e/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/cfb30cf3e321215e/badge.svg)](https://brick.blue/agent/cfb30cf3e321215e?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.