> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gloo.com/llms.txt
> Use this file to discover all available pages before exploring further.

# 2026-10-23 — Forge updates

> listOnBehalfOfGrants, listHoldersAt and getCompanyAccessOverview take limit and cursor, and a Trust Fabric page says isDone exactly when it has no cursor. Pause, resume and terminate an agent, repair its accountability and ask for its setup with any credential that holds the key at the agent's home. Five agents:read routes and MCP tools list an agent's procedure and tool grants, its relationships, its recent knowledge activity and the knowledge scopes it reads, each fenced at its own home. Four agents:read routes and MCP tools open one agent the way the Console's detail page does, and the agent list searches and filters like the Console. Seven platform:manage writes set capability chains, turn capabilities off, set provider options, enable or disable providers, add provider records and bind org units. The workflow debugger, the human task view, My work and webhook delivery lists mask credential values. Re-running, restarting, rewinding, fixing, analysing or replaying a run's sandbox now requires that you can see the run. Run views, run lists, checkpoints and stream events mask credential values; a rerun sends only the inputs you change. A run's sandbox lineage and its step's sandbox commands now require factory read access for every company the run carries. Your credential's own compatibility role is no longer listed in getMyAuthority; what it allows is unchanged. Entries, cases, records, annotations, sources, settings, re-embeds, golden sets, exports and memory forgets made through the API record who made them. Forge MCP's tool list leaves out the core tools a credential's permissions cannot call; the Platform API still decides every call. Three new tools search, describe and call any Forge HTTP API operation, filtered by your connection's tool groups. Forge MCP's Platform API requests name the tool and the MCP host, so Forge can count use by tool. Two agents:read routes and MCP tools read a model's full metadata and the fallback chains, and the model and agent lists filter like the Console. GET /api/v2/runs/getMarkdown returns meta.nextCursor when a page stops inside a transcript; pass it as cursor for the rest. Token usage and other fields that only describe a credential are no longer masked; authorization, cookie and session values are. The run list names input keys only, and run detail, the debug bundle and every run read mask credential-named values and assigned credentials. A key's or token's scopes now narrow the permissions an operation decides along the way, at a record's org unit, not only the ones it requires up front. Seven routes and MCP tools read a tool the way the Console's tool detail page does, and the tool list filters and sorts like the Console. Forty-one public run, checkpoint, event, handoff and approval queries that returned run content unmasked, and that nothing called, are gone. Ten admin routes run the Console's own webhook and dead-letter operations for a platform key: list, deliveries, health, pause, resume, revoke, test, and the dead-letter list, stats and replay.

**2026-10-23**

Trust Fabric: paged access reads, and isDone exactly when there is no cursor.

* [`listOnBehalfOfGrants`](https://docs.gloo.com/forge/reference/http-api/governance/listOnBehalfOfGrants) and [`listHoldersAt`](https://docs.gloo.com/forge/reference/http-api/governance/listHoldersAt) take `limit` and `cursor` and return one page at a time (15 grants and 25 holders by default). While `meta.hasMore` is `true`, pass `meta.nextCursor` as `cursor`.
* [`getCompanyAccessOverview`](https://docs.gloo.com/forge/reference/http-api/governance/getCompanyAccessOverview) pages its three populations together (8 rows of each by default), with `meta.hasMore` and `meta.nextCursor`. A population with rows still to come has coverage `partial` with reason `pagination_remaining`.
* [`getAgentAccessOnBehalfOfReport`](https://docs.gloo.com/forge/reference/http-api/governance/getAgentAccessOnBehalfOfReport), [`listEvidence`](https://docs.gloo.com/forge/reference/http-api/governance/listEvidence) and [`simulateTrustPolicy`](https://docs.gloo.com/forge/reference/http-api/governance/simulateTrustPolicy) say `isDone: true` exactly when `continueCursor` is `null`. Before, a page could say `isDone: false` with no cursor to continue from.
* Forge MCP: `limit` and `cursor` on `forge_list_on_behalf_of_grants`, `forge_list_holders_at` and `forge_get_company_access_overview`.

**2026-10-23**

Agent administration over the API.

* `POST /api/v2/agents/pause`, `resume` and `terminate` operate an agent's kill switch with `switches:use` at its home. A terminated or archived agent can no longer be paused or resumed, a draft is never resumed, and a call that changes nothing answers `changed: false`. The Console's pause, resume and terminate follow the same rules.
* `POST /api/v2/agents/assignOwner` and `acknowledgeReview` repair an agent's accountability with `agents:manage` at its home; `attestIdentity` does too, and needs a person (a Personal key).
* `POST /api/v2/agents/requestSetup` asks for an agent's missing setup with `agents:read`, 20 times an hour per credential (`429 rate_limited` past that).
* MCP: seven new tools in the `agents` group, from `forge_pause_agent` to `forge_request_agent_setup`.

**2026-10-23**

An agent's grants, relationships and knowledge over the API.

* `GET /api/v2/agents/listProcedureGrants` lists the procedures granted to or denied to an agent; a procedure's name is shown where you hold `workflows:read` at its home.
* `GET /api/v2/agents/listGrants` lists its tool grants, tool-set rows and the capability set it may use when it runs, by natural key.
* `GET /api/v2/agents/getRelationships` returns its worker, position and Job, Access and workflows, each part only where you may read it; the owner is only whether one is present and active.
* `GET /api/v2/agents/listKnowledgeActivity` and `listReadableScopes` (also `knowledge:read`) return the cases it recently authored and cited and the knowledge scopes it reads, limited to what your credential may read.
* These need `agents:read` at the agent's home. A missing, PERSONAL, unhomed or unreadable agent is one `404`.
* MCP: `forge_list_agent_procedure_grants`, `forge_list_agent_grants`, `forge_get_agent_relationships`, `forge_list_agent_knowledge_activity` and `forge_list_agent_readable_scopes`.

**2026-10-23**

Agent configuration, readiness, setup request and templates over the API.

* `GET /api/v2/agents/getConfiguration` returns an agent's configuration as the Console's detail page shows it: identity, model and fallback chain, prompt, run limits, external inference controls, memory, and the skills and tool sets it holds. Never its LLM-proxy key, owner, user or creator ids, attestation, files, embeddings or synthesis request.
* `GET /api/v2/agents/getReadiness` returns its "Ready to run" report, each failed check naming only the kind of fix; `GET /api/v2/agents/getSetupRequest` returns its open setup request, or `null`.
* These need `agents:read` at the agent's home. A missing, PERSONAL, unhomed or unreadable agent is one `404`; an unavailable agent store is `500`.
* `GET /api/v2/agents/listTemplates` lists the platform-wide agent templates under `agents:read` at the platform scope.
* `GET /api/v2/agents/list` accepts `search`, `executionModel` and `tier`, matching the Console's agents page.
* `listTaskRuns` and `listConsultations` now leave out rows that name a PERSONAL agent.
* MCP: `forge_get_agent_configuration`, `forge_get_agent_readiness`, `forge_get_agent_setup_request` and `forge_list_agent_templates`; `forge_list_agents` takes the new filters.

**2026-10-23**

Configure capabilities and providers over the API and MCP.

With `platform:manage`, `POST /api/v2/capabilities/setChain`, `/capabilities/disable`,
`/providers/setOptions`, `/providers/enable`, `/providers/disable`, `/providers/createRecord` and
`/capabilities/bindOrganization` (and their `forge_*` MCP tools) change capability and provider
configuration as the Console does, each idempotent with an `Idempotency-Key`. Writes are recorded
under the calling key or External App. Options that repoint a provider at another host (`apiUrl`,
`baseUrl`, any `*Url`) stay Console-only and are refused with `400`.

Disabling a capability, or disabling a provider, now also takes effect at runtime: the provider records
that resolution reads are turned off, in the Console too. Binding options can no longer hold a secret.

**2026-10-23**

Console: credentials masked in debug attempts, human tasks and webhook deliveries.

* The workflow debugger (an attempt's replayed inputs and workflow arguments, captured and simulated requests, its history, comparisons, previews and tool calls), the human task view, **My work** (including item titles) and webhook delivery lists now mask credentials as run views do: a value under a credential-named field, a credential-shaped string, and a value assigned to a credential name in text read `[REDACTED]`.
* A webhook delivery's payload in the delivery list is masked. The payload sent to the subscriber is unchanged.

**2026-10-23**

Console: run actions check that you can see the run.

* In the Console, re-running a run with its inputs, restarting it from a step, rewinding it to a checkpoint, asking the Workflow Architect to fix it, starting an AI analysis of it, and replaying or comparing its sandbox snapshots now each require that you can see that run: workflow read access where the run lives and for every company it carries. A run you cannot see is reported as not found, the same as in the run list. The API already worked this way.

**2026-10-23**

Console: credentials in runs are masked.

* The Console now masks credentials in a run's inputs, goal, error and outputs, in checkpoints, AI analyses and live run events, as the API does: a value under a credential-named field such as `password`, `otp` or `backup_code`, a credential-shaped string, and a value assigned to a credential name in text read `[REDACTED]`. The masking happens on the server, so the values never reach your browser.
* **Rerun with modified inputs** sends only the inputs you change; the run reuses the prior run's stored values for the rest, including the masked ones. File inputs are uploaded again, as before.
* The launch dialog's last-run values leave out any field that held a credential, so you enter it again.

**2026-10-23**

Console: sandbox views check the run's companies.

* In the Console, a run's sandbox lineage and a step's sandbox commands now require factory read access where the run lives and for every company it carries, as the API already did. A run carrying a company you cannot read is refused.

**2026-10-23**

getMyAuthority leaves out your credential's compatibility role.

* [getMyAuthority](https://docs.gloo.com/forge/reference/http-api/governance/getMyAuthority.md) and `forge_get_my_authority` no longer list a migrated API key's or External App's own compatibility role, in `grants` or in a permission's `granted` roles, as [listMyGrants](https://docs.gloo.com/forge/reference/http-api/governance/listMyGrants.md) already leaves it out. Every permission's `effective` answer is unchanged: the permissions that role carries still count.

**2026-10-23**

Knowledge API: every write records who made it.

* Every knowledge write made through the API is now recorded as the person who owns the Personal key, as if they had made it in the Console, and its audit event names the key. This covers knowledge added and cases created or edited, authored records and annotations, sources, learning settings, re-embeds, golden sets, exports, and forgetting a memory. An External App is recorded as the app, with the people who granted its access, and a platform key as the key. See [Knowledge API](https://docs.gloo.com/forge/reference/http-api/knowledge).
* A learning setting changed with a Personal key is now audited as a person's change, not the system's.

**2026-10-23**

Forge MCP: a credential-filtered tool list.

* `tools/list` now leaves out each core tool whose required permissions your credential does not hold, so a read-only key is offered the reads and not the writes. Tools no permission gates stay listed, and the Platform API still decides every call. See [Credential-filtered tool list](https://docs.gloo.com/forge/reference/mcp-server.md#credential-filtered-tool-list).

**2026-10-23**

Forge MCP: search, describe and call any HTTP API operation.

* **`forge_search_operations`**, **`forge_describe_operation`** and **`forge_call_operation`** let an agent reach any Forge HTTP API operation, not only those with a dedicated tool. Search by words, read an operation's input and output schemas, then call it with your own credential.
* The server authorizes every call, and its answer comes back unchanged as `{ status, body }`.
* Your connection's tool groups decide which operations the tools show and call: an operation outside your selected groups is refused with `tool_group_not_selected`.

**2026-10-23**

Forge MCP: usage headers.

* Each Platform API request a Forge MCP tool call makes carries `X-Forge-Mcp-Tool` and, where the MCP host gave a name Forge can count, `X-Forge-Mcp-Client`. Forge counts use by tool, route and host; it records no credential, person or argument. See [Usage headers](https://docs.gloo.com/forge/reference/mcp-server.md#usage-headers).

**2026-10-23**

Model detail, fallback chains and model filters over the API.

* `GET /api/v2/models/getDetail` returns one catalog model's full metadata; its rates appear only when you hold `gateway:read` at the platform scope.
* `GET /api/v2/models/listFallbackChains` lists the model fallback chains, system chains first, with each chain's models in priority order.
* `GET /api/v2/models/list` accepts `provider`, `status`, `isActive`, `search` and `sort`, matching the Console's models page; without `sort` the order is unchanged.
* `GET /api/v2/agents/list` accepts `modelId`: the agents pinned to one catalog model.
* MCP: `forge_get_model_detail` and `forge_list_fallback_chains` in the `models` group; `forge_list_models` and `forge_list_agents` take the new filters.

**2026-10-23**

Run Markdown export continues a long transcript by cursor.

`GET /api/v2/runs/getMarkdown` (and `forge_get_run_markdown`) now pages a large export. A page stops
on a step or turn boundary once it holds about 3 MiB of rendered Markdown or nears the request's
read limit, and then returns `meta.hasMore: true` with `meta.nextCursor`. Pass that value as `cursor` to get the rest;
the pages together hold every turn exactly once, and the last page has `meta.nextCursor: null`. Later
pages are titled `# Run dump (continued)` and carry only the remaining steps. A cursor the export did
not issue is a `400`.

**2026-10-23**

Runs API: usage numbers are no longer masked.

* Run reads no longer mask fields that only describe a credential: `tokenUsage`, `tokenCount`, `token_type`, `otpEnabled`, `sessionId` and similar keys keep their values. A run read briefly returned `[REDACTED]` for token usage.
* Values under `authorization`, `cookie`, `session`, `passwd`, `access_key` and `totp_seed` keys are now masked, and a `{ key, value }` or `{ name, value }` pair whose name is a credential has its value masked. See [Runs API](https://docs.gloo.com/forge/reference/http-api/runs#inspecting-a-run).

**2026-10-23**

Runs API: launch inputs are masked.

* `GET /api/v2/runs/list` and `forge_list_runs` no longer return a run's launch input values. Each row names the input keys in `argKeys`; read one run for its inputs.
* `GET /api/v2/runs/get`, `forge_get_run` and the debug bundle mask a run's launch inputs, `goal` and `error`. A value under a credential-named key such as `password`, `otp` or `backup_code` reads `[REDACTED]` whatever it looks like.
* Every run read also masks, in free text, the value assigned to a credential name, such as `backup code: 48213907`. See [Runs API](https://docs.gloo.com/forge/reference/http-api/runs#inspecting-a-run).

**2026-10-23**

Platform API: scopes narrow every decision.

* Many operations decide a second permission at the record's org unit: a run control first checks `runs:read` on the run, an agent write checks `agents:read` on the agent, a builder conversation checks `chat:read` on its companies. Those decisions now use your role grants **narrowed by the credential's scopes**, the same rule as the operation's own permission. A credential whose scopes stop short of that second permission gets the operation's not-found answer, or the withheld section, even when its role grants hold it.
* To keep a call working, give the key or token the scopes for every permission it relies on. See [Permissions and scopes](https://docs.gloo.com/forge/reference/conventions.md#permissions-and-scopes).

**2026-10-23**

A tool's insights over the API.

* `GET /api/v2/tools/listAgents` lists the agents holding a tool, each decided at its home; the ones you cannot read are counted, never listed.
* `GET /api/v2/tools/listExecutions` lists a tool's newest calls. A call's agent, run and content appear only where you can read them, and the raw input and output never do.
* `GET /api/v2/tools/getUsage` returns a tool's calls, failures, cost and top callers; `GET /api/v2/tools/getSandboxRejections` counts its rejected sandbox commands.
* `GET /api/v2/tools/listAuditHistory` pages a tool's history with the kind of actor only.
* `GET /api/v2/tools/listMostUsed` and `GET /api/v2/tools/listNeedingAttention` list the catalog's most used tools and the ones needing attention.
* `GET /api/v2/tools/list` accepts `category`, `source` and `sort`.
* MCP: seven new tools in the `agents` group; `forge_list_tools` takes the new filters and sort.

**2026-10-23**

Console functions: unused public run reads removed.

* Forty-one public reactive queries that returned run content without masking, and that neither the Console nor any client called, are removed. They include `runsSteps.getLiveState` and `opsInternal.getThreadConversation`, which this reference listed. Read runs through the masked reads: `runsReads.get`, `runsSteps.getTimeline` and `runsSteps.listCheckpoints`.
* `executionEvents.structuralByRun`, which the run analysis tool calls, stays and now masks credentials in the events it returns.

**2026-10-23**

Webhooks admin over the API.

* `GET /api/v2/webhooks/admin/list`, `/deliveries` and `/health` read every webhook subscription, a subscription's deliveries and their 24-hour health, with `webhooks:read`. A subscription's auth token appears only as `hasAuthToken`.
* `POST /api/v2/webhooks/admin/pause`, `/resume`, `/revoke` and `/test` change or test any subscription, with `webhooks:manage`. Each takes an `Idempotency-Key`.
* `GET /api/v2/webhooks/admin/dead-letters` and `/dead-letters/stats` read the dead-letter queue with `platform:read`, and `POST /api/v2/webhooks/admin/dead-letters/replay` replays a pending entry with `webhooks:manage`. A replay records the key as the actor who replayed it.
* These routes take an API key. An External App is refused with `403`, even when it holds the permission: an app manages its own subscriptions through `/api/v2/webhooks`.
* These routes run the same operations as the Console's Webhooks page. Creating a subscription and rotating its secret stay with the External App routes and the Console.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.