A
A2A (Agent‑to‑Agent)
A protocol for machine‑readable agent capability cards (AgentCard). Active agents in Forge can opt into discovery viapublishedForDiscovery: true.
Access check
A question you put to Trust Fabric: does this person or agent hold this permission at this scope, and why or why not. Forge Console: Trust Fabric → Access → Access check, which needsgrants:read. See Access check.
Admission
The review a newly synthesized skill, agent or procedure gets before it joins the catalog: a panel of judges scores it for coherence, duplication, quality and whether its declared capabilities resolve. Proposals waiting for a decision are listed worst-scored first under Platform → Judges → Admissions. See Admissions.Agent
An AI worker with an identity, a model, a prompt, and the skills and tools it is granted. Before it can run a workflow step it needs a worker that sits in a position with a Job, an active owner, an attested identity and the Access its steps need; its Ready to run checklist shows what is missing. See Agents and Check that an agent is ready to run.Agent composition
How Forge builds an agent’s configuration for one dispatch: it loads the definition, resolves the prompt, combines the skills the agent is granted with those the step asks for, merges its tool sets and picks the model. Composition does not run Trust Fabric; each dispatch is governed separately. See Agent composition.Agent definition
The declarative specification of an agent: its identity, its capabilities and its runtime configuration. A change to its model, prompt, governance or rung changes its definition fingerprint, so its owner must attest the new version. See Define an agent.Agent kind
What kind of agent it is: System (a platform agent), Worker (an agent that does your organization’s work) or Personal (one person’s own agent). Stored asagentType (SYSTEM, WORKER or PERSONAL); older material calls it the agent’s tier. It is not how much the agent may do on its own (the rung), not its LLM routing tier and not its agent risk tier. See Agents.
Agent node
The workflow node that hands a step to a worker. Forge Console labels it Agent; its stored node type isproduce. When the node’s worker is an agent, Forge dispatches that agent through Trust Fabric. When the worker is a person, the step becomes a human task on that person’s My Work. The other node types are router, join, publish, procedure and notify.
Agent risk tier
T1–T4, the classification an agent gets at intake. It is derived from the agent’s rung plus its vendors, its fiduciary flag and its financial authority limit. T1 and T2 are approved automatically; T3 and T4 go to review (T4 to the security team). Not the same as a request’s risk level (R0–R2 on a request), and not an autonomy level — that is the rung.
Agent session
One finite conversation or piece of work by an agent: a chat in a direct, team, project, personal or group channel, a factory worker’s or manager’s turn, a workflow step, or system work. Each session records its tokens and cost. Forge Console: Workforce → Agents → Sessions. See Agent sessions.Agent template
A reusable agent definition you create a managed agent from. The template supplies configuration; the new agent still needs its own identity, access, credentials and workflow context before it is ready to run. Forge Console: Workforce → Agents → Templates. See Agent templates.Alert
A rule that notifies people when a condition trips. Two kinds exist, so say which. An Observe alert rule counts matching platform events in a time window and notifies a bell or a Slack channel when the count trips, or, as a deadman rule, when nothing matches (Observe → Alerts). An Analytics alert compares a metric, such as daily cost or step failure rate, with a threshold (Analytics → Alerts). See Observe alerts and Analytics alerts.API key scopes
Narrowing strings on an API key or in an access token’sscope claim. A scope grants nothing: the effective permissions are the actor’s role grants intersected with what its scopes map to. Always say “API key scopes”, never bare “scope”. See Permissions and scopes. Outbound vendor OAuth scopes are a separate thing.
API keys (emergency-stop door)
The door that stops every API-surface credential: External Apps and Personal keys, reads included. “API keys” is the umbrella name for those credentials; no single Console page is called API Keys.Approval
A human task of the Trust Fabric hold kind: a human-in-the-loop (HITL) decision required before a held action proceeds. Triggered by theapprovalRequired gate (16th and last in the engine sequence) or a require_approval policy match. Answered in Forge Console, Slack or the Platform API; the first answer wins.
Architect
The Workflow Architect: the platform agent that drafts and edits workflow graphs from plain language. It works in the Architect drawer of the workflow builder. See Use the Architect.Audit event
One recorded entry of who did what: the actor (a person, an agent or a credential), the action, the record it touched and when. Role grants and revocations, credential changes, configuration edits and refusals each write one. The compliance export pages them over the API (GET /api/v3/compliance-export-audit). See Audit and replay.
B
Blocker
A task that another task waits on. Planning → Blockers is a read-only list of tasks that still name at least one blocker; it does not create or resolve blockers. See Blockers.Budget envelope
A spend ceiling at one flat scope:global, gateway, agent or externalApp (one External App), over a daily, weekly or monthly period. The budgetEnvelopes gate checks every envelope that applies; an exhausted envelope pauses dispatch. See Budgets and cost.
Budget hierarchy
The org-unit budgets, a budget tree that mirrors the organization tree (team → department → company) over monthly, quarterly or annual periods. A dispatch must fit every org-unit budget on its ancestor path; thebudgetHierarchy gate (12th in the engine sequence) checks them. See Budgets and cost.
Builder
A platform agent that synthesis dispatches to create a missing item: the Skill Builder, the Agent Builder or the Procedure Builder. Analytics → Agent Performance → Builders shows how the Skill Builder and Agent Builder are doing. Builder is also the name of an access role; see Words with more than one meaning. See Builders.C
Capability
A typed interface contract for a service the platform depends on (LLM inference, embeddings, secrets, task tracking, org structure, sandboxes and more). Each domain is served by the provider records an operator enables. Some domains have a foundation provider that Forge pins; others, including inference and embeddings, have none and stay listed, unconfigured until an operator enables a provider. Platform code depends on the domain’s contract and never imports a vendor module directly. See Capabilities.Capability adapter
A concrete implementation of a capability interface for a specific vendor or backend. Examples: the 1Password adapter implementssecrets_store, the Linear adapter implements project_management, and the Rippling adapter implements org_structure. An operator selects an adapter by enabling its provider record, which names the vendor connection and non-secret options; no code changes are needed to swap providers.
Capability domain
A named platform capability (e.g.inference, embeddings, secrets_store, project_management). Forge defines 20 domains. See Capabilities.
Capability fallback chain
Not a provider failover. Forge never silently switches a capability domain to another provider: a single-dispatch domain uses its active provider record, a fanout domain delivers to every enabled provider, and an unconfigured domain fails with a domain-specific error. Model-level failover is the separatellm_fallback_chains domain, which orders models, not providers. See Capabilities.
Capability provider
One provider record that serves a capability domain: the foundation provider Forge pins, or an external capability provider an operator enables. A record names its adapter, its vendor connection and its non-secret options, and is enabled or disabled under Platform → Capabilities. A single-dispatch domain uses its active record and a fanout domain delivers to every enabled one. See Capabilities.Channel
A scope for chat conversations. Channels can be factory‑scoped, project‑scoped, team‑scoped, direct (DM), or personal (PA‑only).Channel memory
The middle layer of the three‑layer agent memory model. Persists across sessions within a channel; institutional knowledge.Checkpoint
A snapshot of workflow run state captured at certain points. Powers rewind‑to‑checkpoint and branch‑from‑checkpoint actions.Client health
A summary of every client’s open Freshservice tickets, read from a read-only copy of the Freshservice ticket list that Forge refreshes about every two minutes. Freshservice stays the system of record. Forge Console: Planning → Client health. See Client health.Command
An operation an agent runs in a sandbox. A catalog command (Tier 1) is typed and validated and runs under a declared network policy; Forge syncs the built-in ones from its catalog every hour, and a skill grants commands to the agents that hold it. A free-form command (Tier 3) is one an agent issues throughsandbox_action; Trust Fabric records each one, and repeated patterns can be promoted into the catalog. Forge Console: Platform → Commands (Catalog and Audit tabs). See Commands.
Connected account
Outbound. One provider-side account authorized through an OAuth Application — for example a single QuickBooks company or realm. One OAuth Application can authorize several connected accounts without conflating their identities or refresh-token chains. Visible in Forge Console under Platform -> Vendors -> vendor -> Connections. Do not confuse this with an External App, which is the inbound direction.Connection
A word with three meanings, so say which. A vendor connection is one API of a vendor Forge calls out to, under Platform → Vendors → vendor; it carries a declaration and the credentials Forge presents, and a procedure or workflow node names it. An environment connection holds a platform’s master credential (Convex, GitHub or Vercel) for pushing Vault secrets, on Platform → Settings → Secrets → Connections. Settings → Connections lists the outside identities your Personal Agent may use. See Vendors and Environments.Cost
What a model call cost, computed when the call is recorded against the price in effect at that moment. The price is stored with the call, so a later price change does not rewrite history. Cost rolls up by agent, model, run and gateway, and budget envelopes and org-unit budgets cap it. Forge Console: Analytics → Cost. See Budgets and cost.Credential
What Forge presents to a vendor when it authenticates on someone’s behalf. The credential registry groups credentials by vendor and connection, shows whom each one serves and whether it has been proven against the live provider, and holds the credentials waiting for approval in its Needs review count. Forge Console: Platform → Vendors → Credentials. A credential is not a secret in a Vault. See Credentials.Credential binding
Outbound. Grants one Forge scope access to a Connected Account. It is the ordinary Forge Credential that runtime tools, agents, procedures, sandboxes, and capability providers resolve — they never select or receive an OAuth Grant ID. One connected account can serve several scoped credential bindings. This term keeps that meaning. A workflow node’scredentialBindings map is a different object — a statement on the node about which Credential a Connection should reach for, not the Credential itself; see Bind node credentials.
Critical path
The tasks in one active roadmap ordered by how little time they have left before their milestone. Planning → Critical Path is a read-only urgency list, not a dependency graph. See Critical path.Customer
A canonical record of a client organization that projects, pods and cost are attributed to. Reading customers needscustomers:read. Forge Console: Planning → Customers. See Customers.
D
Decision (Trust Fabric)
The record Trust Fabric returns for one evaluation: its disposition (pass, block or hold), each gate’s outcome, the budget and role-limit snapshots, and an explanation with unblock hints. Forge Console lists them on Trust Fabric → Decisions. See What a decision tells you.
Declaration
What a tool, procedure, or connection declares about itself: its kind (read, compute, or write — a financial or destructive write is a write, and there is no stricter kind), whether using it sends something out (delivers content to an outside party; calling an outside system in order to read is not this), and whether it touches sensitive data (financial records or PII). Absent means undeclared, which is treated as the strictest case rather than as “declares nothing”. Stored, shown, and editable today; the hold table that reads a declaration against an agent’s rung is separate work. Tool declarations are visible under Platform -> Tools -> tool -> Governance; Connection declarations are visible under Platform -> Vendors -> vendor -> Connections. See Tools and Vendors.
Delegated run
A run that gives an agent a goal, a budget and a deadline instead of a fixed graph. Start one from Production → Runs with + Delegated Run. It is the only kind of run that can be paused. Not the same as delegated work, where one agent hands a task or a question to another. See Delegated work.Delegation
A grant that lets a published workflow version use a company’s credentials. Review and revoke these grants under Trust Fabric → Access → Delegation, which needsgrants:read. Not a delegated run. See Delegation.
Disposition
The outcome of aGovernanceDecision: pass, block, or hold.
Door
One of the three emergency stops for one kind of actor: people, API keys or agents. A stopped door refuses new work from that kind of actor withgovernance_door_stopped until an operator resumes it. “Door A” and “Door B” are older names for the surfaces.
E
Emergency stop
A control on Trust Fabric → Emergency stops that refuses new work without a deploy: the platform kill switch (Stop everything) or one of the three doors. Using one requiresswitches:use. What each stops is in Emergency stops.
Environment
A word with three meanings, so say which. A deployment of Forge, such as production or staging, with its own API host. The Environments page (Platform → Settings → Secrets), where Vault secrets are pushed to outside platforms through connections, instances and mappings. And the environments a role’s limits allow. See Conventions → Base URL and Environments.Eval
An evaluation set of fixed test cases for an agent or workflow, and the metered runs that score against it so two runs can be compared. Reading needsagents:read; starting a run needs agents:write and inference:use. See Evals.
External App
Inbound only. An OAuth2 client registered with Forge: a partner application that exchanges aclient_id + client_secret at POST /oauth/token for a short-lived Forge JWT, then calls the OpenAI-compatible inference surface (/api/inference/v1/*) and/or the Platform API (/api/v3/*, or the /api/v2/* compatibility surface). It is a first-class principal — the tenant boundary that keys governance, budgets, memory isolation, and webhook subscriptions. Managed at Platform → Developers → External Apps in Forge Console; see External Apps (operator guide).
The term means only this. It does not mean a vendor Forge calls out to — that is an External Capability Provider plus a Virtual Key, or, for authorization-code vendors, an OAuth Application plus a Connected Account and a Credential Binding; see Connect an external service and Vendors (operator guide). It does not mean a chat-platform install such as a Slack workspace connection (see Slack). Those are separate primitives with separate schemas and separate console pages.
The reliable test is the arrow, not the word “app”: an External App is inbound (someone else’s software calling Forge); everything in the paragraph above is outbound (Forge calling someone else’s software).
External capability provider
Outbound. A vendor-backed adapter for a capability domain (e.g. 1Password forsecrets_store, Linear for project_management, Rippling for org_structure). Enabled through its provider record under Platform → Capabilities. An enabled external provider is ordered ahead of the domain’s pinned foundation provider, so it becomes the active provider; a single-dispatch domain uses only that active record and does not retry down the list. In a domain with no foundation, enabling one is what makes the domain usable. See Connect an external service.
F
Factory
An autonomous production unit. Pairs a Factory Manager agent with a team, a budget, channels, and (optionally) a dev environment. The unit of operational scope for hybrid workforce work.Factory Manager
The platform agent that runs a Factory: it coordinates the task lifecycle, team handoffs, budget and source-control work. See Factories.Factory Worker
A Worker agent that implements factory coding tasks using source-control tools and the dispatch-boundsandbox_action when isolated execution is required.
Fallback chain
An ordered pool of models, each with a weight, that you assign to an agent; the first entry has the highest priority. An agent with an active chain dispatches from the chain, not from its tier routing or its default model, even when those are healthy: changing the default model does not move that agent’s traffic. A call that names a model explicitly uses that model and skips both the chain and tier routing. Otherwise Forge skips the chain only when it is missing or inactive, or none of its models can be used (no model is enabled, or no enabled model is available); the agent then uses its tier routing or default model. Forge Console: Platform → Models → Fallback Chains. It orders models only: Forge never falls back from one capability provider to another (see Capability fallback chain). See Fallback chains.Feature flag
A workspace switch that turns an experimental feature or Console page on or off, for everyone or for chosen users, agents, teams, departments, roles or a percentage of people. Forge Console: Platform → Settings → Feature Flags. See Settings.file_get / file_put
The file tools Forge gives an agent for one dispatch. file_get reads only the file IDs that dispatch authorizes; file_put writes only to destinations it allows, such as a declared workflow output. writeArtifact is retired; putFile and getFile remain supported, deprecated aliases for file_put and file_get. See Files and bindings.
Fiscal calendar
A fiscal-year definition that workflow input expressions use, for example in a month-end close workflow. Forge Console: Platform → Settings → Fiscal Calendars. See Fiscal calendars.Forge Console
The web app operators use to run Forge. Its sections are Chat, Planning, Production, Workforce, Observe, Analytics, Trust Fabric and Platform. See Forge Console.Foundation provider
The provider Forge pins for a capability domain, such asforge for file hosting, notifications and knowledge, or vercel for sandbox. It stays in the domain’s provider records, ordered after any provider an operator enables, so it serves the domain whenever no other provider is enabled. Not every domain has one: inference, embeddings, source control and org structure, among others, fail with a domain-specific error until an operator enables a provider. Older material calls it an internal capability provider. See Capabilities.
G
Gate sequence
The fixed order in which Trust Fabric evaluates its 16 gates for an action, stopping at the first block: the global kill switch and the agents door first, then agent status, factory status, chat response, identity (6th), permission, concurrency, rate limit, three budget gates, autonomy holds (13th), NHI entitlement, policy rules and approval (16th). Each gate checks one aspect of the action. Agent dispatch runs five prechecks before it. The generated table is The gate sequence.Goal
A planning target with key results, shown on Planning → Goals. The API, the schema and the permission keys call the same record an objective (/api/v3/objectives, objectives:read, objectives:manage). Write goal in prose and objective only for the API resource or a permission.
Graph (Workflow Graph)
The shape of a workflow: a directed graph of nodes and edges. The node types are Agent (stored asproduce), router, join, publish, procedure and notify. Work for a person runs through an Agent node whose worker is a person; there is no separate human node type. See Node types.
Group
A set of people that spans the organization tree without changing anyone’s position or reporting line. Group membership coordinates work and grants no permission. Forge Console: Workforce → Organization → Groups. See Groups.H
Hold
AGovernanceDecision disposition meaning approval is required. Execution pauses for a human decision.
Holder
An actor that holds role grants: a person, an agent, an API key or an External App. Trust Fabric → Access → Holders lists the holders whose roles reach a scope. An org unit is where a grant applies, never a holder. See Access → Holders.Human task
Any point where Forge waits for a person, such as an approval, an Agent node assigned to a person, an agent’s question or a review. People answer them in My Work, and the first answer wins. The kinds and their lifecycle are in Human tasks.I
Ingress
Inbound. An outside system starts a workflow run by calling the workflow’s capability URL, optionally signed with HMAC. The URL keeps working only while its creator holdsworkflows:manage. Not a webhook, which goes out. See Signed workflow ingress.
J
Job role
What the work of a position is: its responsibilities and, for a position an agent holds, the instructions, skills and tool sets the agent uses there. The agent’s Ready to run checklist calls it the position’s Job. A job role grants no permission; it is not an access role. Forge Console: Workforce → Organization → Job roles. See Job roles.Join node
A workflow node type that synchronises multiple incoming branches before proceeding. Strategies:all, any. Legacy graphs that still declare n_of_m keep running, but new graphs cannot author it.
Judge
A platform agent whose only job is to grade a piece of work against a written rubric and return a verdict. Judges grade skills, agents, procedures, workflow designs, completed runs and knowledge conflicts. Operators can override a verdict, and those overrides measure how often each judge agrees with people. Judges move through provisional, approved and deprecated stages. See Judges.K
Knowledge artifact
One durable entry Forge can retrieve, cite and govern: a lesson, policy, how-to, reference, FAQ or note; a structured record; a file; an item synchronized from an outside system; or an agent memory promoted into knowledge. Its knowledge scope decides who can read it, and its grade (provisional, proven, contested or retired) says how far to trust it. Automatic grading can move an artifact only to proven or contested; any other change needs a person. See Knowledge.Knowledge source
An outside system Forge reads knowledge from, such as a wiki space or a folder of documents. Forge copies each of its items into a case in one knowledge scope, so a synchronized item is graded, cited and audited like any other knowledge artifact. Forge Console: Knowledge → Sources. See Synchronized knowledge sources.L
LLM provider
An access channel Forge uses for model inference, with its base URL, adapter kind and default credential. A provider without a credential cannot be switched on. Forge Console: Platform → Models → Providers. Not a capability provider. See LLM providers.LLM routing tier
The model class an agent asks for:nano, low, mid, high or frontier, stored in the agent’s tier field. Skill minimums and tenant caps still apply on top. It is not the agent kind and not its risk tier. See LLM routing.
Long‑term Memory
The bottom layer of the three‑layer agent memory model. RAG‑indexed durable archive promoted from channel memory on a weekly compaction schedule.M
MCP (Forge MCP server)
The server that lets an AI host such as Claude Code work in Forge for a person or an app. It runs as a hosted endpoint or as a local package. A connection lists the tools for the jobs it selects:start (the default), access, work, approvals, find, run, explain and knowledge. Select jobs with the jobs= URL parameter or the X-Forge-Mcp-Jobs header on the hosted endpoint, or with FORGE_MCP_JOBS for a local server. A list replaces the default, so include start to keep it. Jobs change which tools are listed, not what the caller may do. See MCP server.
Model
An LLM in the model catalog, with its per-token cost, context window, capabilities (chat, embedding, vision) and current health. Forge picks the model for each agent turn in this order: a model the call names explicitly; the agent’s active fallback chain; the agent’s tier routing, when the agent declares a tier; and last, the agent’s default model, which also serves as the backup when tier routing fails. Forge Console: Platform → Models. See Models.N
NHI (Non‑Human Identity)
The credential identity an agent presents at dispatch. Validated by theidentity gate (6th in the engine sequence) through a registered NHI provider. When no NHI credential is configured the gate passes and records the verification basis as unconfigured, meaning identity was not actually verified.
NHI entitlement
The gate that checks whether the requested action is within the agent’s credential entitlements, as reported by the configured NHI provider (thenhiEntitlement gate, 14th in the engine sequence). Formerly labeled “NHI scope” (gate id scope). Without an NHI provider configured it passes.
Node
One step of a workflow graph. Each node has a type: Agent (stored asproduce), router, join, publish, procedure or notify. Each run executes a node as a step. See Node types.
Notify node
A workflow node type that always notifies people. It records one notification obligation per (recipient, channel) — bell, Slack, or email — for Forge people (the run starter, the workflow owner, a person, an org unit’s members) and Slack channels, then completes; delivery follows per obligation. It never takes a raw email address; use a Publish Node for outside delivery.O
OAuth application
Outbound. A vendor client registration Forge holds so it can call out to that vendor: client ID, protected client-secret reference, environment, issuer, and rotation generation. Canonicalized by connection target, environment, issuer, and client ID — never by Credential scope — so one vendor application is not duplicated just because several Forge scopes use it. Shown in Forge Console under Platform -> Vendors -> vendor -> Connections as OAuth applications; see Vendors (operator guide). An OAuth Application is not an External App. The names are close and both involve OAuth, but the arrows point in opposite directions: an OAuth Application is a client credential Forge presents to a vendor, while an External App is a client credential a partner presents to Forge. They share no schema and no console page.OAuth grant
Outbound. One authorization joining an OAuth Application to a Connected Account. Owns the granted scopes, lifecycle, generation, and refresh-token reference; refresh is serialized per grant with a lease and generation fencing so a stale refresh cannot overwrite a reconnect. Downstream consumers never see a grant ID — they resolve a Credential Binding.Orchestrator
The durable engine that runs a workflow’s graph node by node. An Agent node runs an agent or a person, depending on its resolved worker. See Workflow execution.Org unit
One node in the organization tree: the company root, a department, a team, a capital partner or a customer organization. Org units are where roles are granted. A role granted at an org unit applies there and in every unit beneath it; to decide whether a caller holds a permission on a record, Forge checks the caller’s grants at the platform and at the record’s org unit and each unit above it. Forge Console calls an org unit an organization in the role dialog. An org unit is not a pod. See Org units.Outcome
A word with four meanings, so say which. A run’s terminal outcome is how it ended: completed, failed or cancelled. A run’s execution outcome says how a completed run got there, such as Completed normally or Completed with handled error; the run page shows it as Execution outcome. A work outcome is Forge’s claim about what a completed run achieved (achieved, achieved with exceptions, or not achieved); a versioned outcome definition decides it, not the workflow, and Planning → Outcomes lists them. A Trust Fabric decision’s disposition (allowed, held or blocked) is what Trust Fabric → Decisions groups and filters by under Outcome. See Outcomes.P
Permission
One thing an actor may do: a verb (See, Use, Edit, Manage or Approve) on a resource, writtenresource:verb, such as runs:manage (Manage runs). The permission catalog is the only list; every permission belongs to one of six families and some are elevated, needing an explicit opt-in before they are given. Permissions are held through roles, never directly. See the permission reference and, in the Console, Access.
Person
One human identity in Forge. A person can hold more than one worker seat, for example an employee seat in one organization and a contractor seat in another, and appears once in people lists. Creating a person does not create a sign-in. Forge Console: Workforce → People. See People.Personal Agent (PA)
A user‑scoped agent. Every workspace member has one. Its kind isPERSONAL (agentType).
Personal key
A person’s own credential for the Platform API (/api/v3/* and /api/v2/*), managed at Settings → Personal keys in Forge Console. It is a general API key, not an MCP-only one. It acts with its owner’s current permissions, cut by its scopes, so it can never do more than its owner; it holds no role grants of its own. Knowledge reads and writes resolve to the owner. It ends when it is revoked or its owner is offboarded. Any active person can create one for themselves; no permission is needed. Two kinds share one authority model: a static key (fmcp_…) and a host sign-in, created the first time an MCP host signs in, which reaches only the hosted MCP endpoint. The stored kind: "mcp" and older material call it an MCP key; this documentation says Personal key. For software that must outlive the people who set it up, use an External App; see Choose a credential.
Platform agent
An agent Forge ships and seeds with the platform, most of kindSYSTEM (agentType). Among them are Factory Manager, Factory Worker, Task Manager, Forge Analyst, Copilot Analysis, the authoring agents such as Workflow Architect and Skill Builder, and the judge agents. Workspaces do not author them. See Define an agent.
Platform API key
A legacy API key that acts as itself, under its own role grants narrowed by its scopes; its credential kind isplatform_key. Existing keys still authenticate, and each operation’s reference says whether it admits one. For new software use an External App; to act as yourself use a Personal key. See Credential kinds.
Pod
A team of people for delivery work, with dated lead and member memberships and optional allocation. A pod is managed by one org unit and can be assigned to customers and projects; joining a pod does not by itself change anyone’s project staffing. A pod is never an authorization scope: roles are granted at org units, not pods. Forge Console: Workforce → Pods.Policy
A declarative governance rule. Conditions trigger an action (block / require_approval / warn / log). Evaluated by the policyRules gate (15th in the engine sequence).
Position
A place in the organization tree, attached to one org unit. A person fills it, or an agent does when the position allows agent assignment; an agent must sit in a position before it can run workflow steps. Assignments are dated, so the history of who held a position is kept. Forge Console: Workforce → Organization → Positions. See Positions.Procedure
A governed unit of work written in code rather than a prompt. It declares typed inputs and outputs, a fixed set of error codes and the outside services it needs, and runs in an isolated sandbox pinned to an exact image. A workflow can use it as a step, and an agent can call it as a tool once granted it; either way it passes Trust Fabric as an agent does. See Procedures.Project
A body of delivery work with its customer attribution, tasks, staffing and outcomes. Reading projects needsprojects:read; creating or changing one needs projects:manage. Forge Console: Planning → Projects. See Projects.
Publish node
A workflow node type that emits a final output to an external destination (Slack, chat, email, storage, API).R
Ready to run
The checklist on an agent’s Overview tab that shows whether Forge will give the agent work. It runs the same checks the runtime runs, under three questions: Where does it work? (worker, position, Job), What may it do? (the agent is on and holds the Access its steps need) and Who answers for it? (an active owner, a current review and a confirmed identity). Each failing check offers one fix. See Check that an agent is ready to run.Relevancy gating
The mechanism that decides whether an agent should reply in a multi‑agent channel. It runs before agent composition and is not part of Trust Fabric.Request
A change request a factory delivers, followed through its delivery lifecycle together with its implementation plans and workflow runs. Forge Console: Production → Requests. See Requests.Roadmap
A plan made of milestones and workstreams, with the status Draft, Active or Archived. Forge Console: Planning → Roadmaps. See Roadmaps.Role
A named, fixed bundle of permissions, such as Builder or Operator. Roles are system-defined and can’t be customized. Compatibility roles are retiring roles kept so their holders don’t lose access; they can be revoked but not given. See Access → Roles.Role grant
One actor holding one role at one scope: a person, agent, API key or app, at the platform or at an org unit. A grant at an org unit also applies under it. Granting and revoking are recorded in the audit log, and revoking disables the grant rather than deleting it. An actor’s authority is the union of its active grants at the scopes that cover a request.Role limits
The limits a role carries into a governance decision: environments, tool allow and deny lists, and data and write access. Recorded on the decision and passed to execution. Formerly called “scope constraints”; the stored field keeps the namescopeConstraints.
Router node
A workflow node type that fans out to one or more downstream branches. Strategies: rules‑based or LLM‑based.Rung
The agent’s place on the four-step autonomy ladder, stored on the agent asrung: Rung 1 Assistive, Rung 2 Retrieval, Rung 3 Supervised, Rung 4 Bounded. The Autonomy holds gate compares it with what an action declares about itself. It is the only autonomy name shown to people. See The four rungs.
S
Sandbox
An isolated session where a procedure or a dispatch runs code, provided through Forge’s sandbox capability. A binding for each dispatch controls who it runs as, what it may do, which files it sees, its network access and its lifetime. See Configure a sandbox.Saved view
A filter saved on Observe → Events, Run History or Logs, kept for yourself or shared with teammates. A saved view on Events can become an Observe alert rule. Manage them from the Views menu. See Saved views.Scope
Where a role grant applies: the whole platform or one org unit. Org-unit, knowledge and credential scopes are instances of this. Other uses are always qualified: API key scopes, vendor OAuth scopes. In the Console, a role card says when a role is given only at the platform or only per company (Access).Secret
A named value kept in a Vault, with a type and a rotation cadence (manual, or every so many days) and a rotation status. Forge can push a Vault’s secrets to Convex, GitHub and Vercel deployment targets. Forge Console: Platform → Settings → Secrets. A secret is not a credential Forge presents to a vendor. See Vaults.Session memory
The top layer of the three‑layer agent memory model. Working context within a single chat session or workflow run.Skill
A packaged set of instructions that can be composed into an agent’s prompt, loaded always or on demand. See Author a skill.Skill set
A named bundle of skills granted to, or denied from, an agent as one unit. Built-in sets are seeded by the platform: their names are fixed but their members can change. Workspace sets are fully managed by operators. Forge Console: Skill Sets, which has no sidebar entry: open it from the command palette or at/platform/skill-sets. API: /api/v3/skill-sets (skills:read to read, skills:manage to change).
Step
One execution of a workflow node within a run. It records the node’s inputs and outputs, its governance decision, its cost and its duration.Surface
Where a request enters Forge: the Console surface (the Forge Console) or the API surface (the HTTP API, SDK and MCP clients). Older material calls them “Door A” and “Door B”; stored workflow-run values keep that spelling (triggeredBy: "door-a" / "door-b").
Syndication
The integration that bridges Forge channels with external chat platforms (Slack first). Messages flow both ways with governance enforced in Forge.Synthesis
How the Workflow Architect fills a gap. When a workflow needs a skill, agent or procedure the workspace lacks and nothing reusable fits, the Architect asks a Builder (the skill, agent or procedure builder) to create one. The new item starts provisional once it passes its structural checks, so the workflow that asked for it can use it at once, and people holdingsynthesis:approve review it later. A failing quality-judge verdict blocks it only when an operator has set that judge gate to enforce. The Curator finds near-duplicates every week and recommends merges. Forge Console: Platform → Synthesis. See Synthesis.
T
Task
A unit of work in a Factory. Nine states:ICEBOX, BACKLOG, READY, ASSIGNED, IN_PROGRESS, BLOCKED, IN_REVIEW, COMPLETE and CANCELLED. The usual path is BACKLOG → READY → ASSIGNED → IN_PROGRESS → IN_REVIEW → COMPLETE; ICEBOX holds items not yet triaged, BLOCKED marks stalled work, and CANCELLED ends a task without completing it. Managed by the Task Manager platform agent.
Tier (Agent Tier)
An older name for the agent kind:SYSTEM, WORKER or PERSONAL, stored as agentType. An agent’s tier field is something else: its LLM routing tier, one of nano, low, mid, high or frontier, which picks the model class.
Token attribution
The mechanism that attributes every token consumed by an agent to a worker, task, workflow, project, objective. Dual aggregation across the worker chain (worker → team → department → company) and task chain (token → task → workflow → project → objective).Tool
An operation a model can call during a turn: a code-shipped action, an external integration defined in the workspace, or a tool Forge adds for one dispatch such assandbox_action, file_put, file_get or load_skill. See Tools and skills.
Tool set
A named group of tools an agent is granted as one unit, directly or through the job role of its position. Code-shipped sets come with the platform; workspace sets are defined in Forge Console under Platform → Tool Sets. See Tool sets.Trace
The record of one workflow run’s execution: its status, start time, duration, tokens, cost and step progress, with failed steps called out. Forge Console: Observe → Traces. See Traces.Trigger
What starts a workflow run without someone pressing Run: a schedule (a cron expression with a timezone, or one time), a call to the workflow’s ingress URL, or an email route. Creating or changing a trigger checks your authority against the published version. Schedules are set on the workflow’s Schedule tab. See Scheduling and triggers.Trust Fabric
Forge’s governance system: the numbered gate pipeline plus the policy engine, NHI registry, audit, approvals, vendor registry, and protected‑data classification.Trust receipt
A tamper-evident record of one run attempt: who ran it, under what authority, which credentials, tools, skills, procedures and models it used, the human decisions, the cost and the artifacts it produced. Each section says whether it is complete, partial, unavailable or not applicable. The record is canonicalized and hashed, and signed where a signing key is configured. It appears as Trust receipt on Production → Runs and on an outcome dossier. See Trust receipts.V
Vault
An app-scoped container for secrets, with a member list whose roles (Admin, Editor, Viewer) decide who may read, write or rotate them. Forge Console: Platform → Settings → Secrets → Vaults. See Vaults.Vendor
A third-party company Forge calls out to, such as Linear or Slack. Platform → Vendors lists each vendor with its connections and the tools, procedures and capability providers that use it, and its Credentials tab holds the credentials Forge presents. A vendor is the outbound direction; an External App calls in. See Vendors.Verdict
A judge’s structured grade on one item: pass, needs work or fail, with a 0–100 score, a score and reason for each criterion, a confidence, a rationale and optional findings. A verdict is authoritative only when the judge’s confidence clears its threshold, and an operator can override it. A Trust Fabric input verdict is a different thing: it records whether a check could read its inputs.Virtual key
A named credential record (VK) that fronts a real external secret (API key, OAuth token, bearer token), encrypted at the application layer. Resolution depends on the VK’s purpose. Fortool_call VKs, dispatch follows the agent’s VK chain — the active VK for (agent, tool) points at a toolCredentials row, which dispatch dereferences to a decrypted secret. For inference_provider, capability_provider, and external_tool_identity VKs, the resolver walks the ownership scope hierarchy (user → agent → project → factory → org unit → system) and returns the first active match. Secret values are held through the secrets_store capability: Forge’s own encrypted store is enabled by default, and 1Password Connect, Pipedream, HashiCorp Vault or WorkOS Vault can be enabled instead. See Virtual Keys.
W
Webhook
Outbound. A signed event delivery from Forge to an endpoint you subscribe. Deliveries notify and can arrive out of order; the event log is the source of truth. An External App’s subscription receives only events that app started. Forge Console: Platform → Developers → Webhooks. See Webhooks.Worker
One seat that performs work, held by a person or an agent. Itskind is EMPLOYEE, CONTRACTOR or AGENT. All three share the same org structure, permissions model, budgets and audit trail. In Forge, seat always means a worker; a position is a place in the organization tree that a worker fills. See Worker.
Workforce
Everyone who does work in Forge, people and agents, as workers in one organization tree under the same access rules, budgets and audit trail. Forge Console: Workforce. See Workforce.Workflow
A named, versioned graph of steps. You edit a draft; publishing it creates an immutable version, and runs use a published version. See Workflows and runs.Workflow run
One execution of a workflow, pinned to the published version it launched with, or to the draft for a test run. Publishing a new version never changes a run already in flight. See Runs.Workflow schedule
A schedule trigger, recurring or one-time, that starts a workflow. Production → Workflows → Schedules lists the workflows you can operate, scheduled and manual, with their recent execution health. See Workflow schedules.Workstream
A strategic initiative that groups milestones and appears as a swim lane on a roadmap Gantt view. Not a project, which organizes one body of delivery work. Forge Console: Planning → Workstreams. See Workstreams.Words with more than one meaning
These words name more than one thing in Forge. Qualify them on first use.See also: Concepts · Architecture Quick Map · What Changed

