Your models, your app's tools, and an API that is also an MCP server.
The agent is a seam, not an engine. Each project picks the model and the harness that drives it, can hand the agent its own application's tools over the Model Context Protocol, and the whole platform is reachable the other way as an MCP server or a plain REST API with scoped keys.
| Harness | What it is, and when to pick it |
|---|---|
| Built-in loop (OpenAI or Anthropic) | The platform's own agent loop over the worker's browser and evidence tools. The default; cheapest to run; no repository access. |
| Hermes | An external agent harness with read-only access to the project's source, so the agent can read routes and selectors before it clicks. Production's default for Jade. |
| Claude agent | Claude Code running on a connected person's own Claude subscription, never an API key, with automatic fallback to another harness when the subscription cannot serve a run. |
Every worker behaviour (retry, recovery from a dead browser, evidence, cancellation) is implemented once in the worker and shared by all three; the harness only decides who is thinking. The document lane has its own provider setting so a model change for tests never touches BRD generation.
MCP in both directions.
Inbound. Register your application's MCP servers on the project. A tag grants them to a test, the tools are discovered and namespaced, and they appear in the transcript like any browser action, under every harness. A misconfigured server degrades that run; it does not crash it.
Outbound. The platform itself is an MCP server with about twenty-seven tools. An agent holding only that connection can list projects, read the catalog, author a test, run it, read the verdict and artifacts, and file an issue, with the same authentication and audit as REST.
tag: mcp-event-config
description: Connects Jade's event-configuration MCP server and
adds its tools to the run.
mcp_servers: [jade-event-config]
# In the transcript the tools appear namespaced:
# jade-event-config__create_hotel({ name: "Grand Plaza", rooms: 40 })
# jade-event-config__set_inventory({ hotel: "Grand Plaza", nights: … })
Keys, scopes and settings.
- API keys with scopes: everything, an area, or an area's read or write half (code-changes:read, releases). Shown once, hashed at rest, revocable, and prefixed qawa_ so a leaked one is greppable.
- Three ways to authenticate: a token from the identity tenant, a registered client credential, or an API key. Access is scoped to the project, not the caller.
- Model keys are write-only, set from Settings, stored in the vault, picked up by workers within a minute, never read back.
- Per-project GitHub identity: a token or an installed GitHub App with short-lived per-repository credentials.
- Environment import: copy a project's whole configuration from another deployment in one action.
Where it stops today
- External MCP callers use the same API-key model as REST; there is no narrower MCP-only credential yet, so hand a client agent a key scoped to what it needs.
- Hermes is an external open-source project; an unpinned upgrade once broke production, and the platform now pins and verifies it. Its release cadence is still not ours.
- The Claude agent runs on a person's subscription and counts against their limits; nobody connected means every run falls back.
- Inbound MCP tools are whatever your server exposes; the platform namespaces and forwards them and does not validate their behaviour.