> ## 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.

# Workforce concepts

> Who does the work in Forge: workers held by people or agents, org units, positions, job roles, groups, pods, and how a caller maps to a worker.

The workforce answers *who does the work*. Forge gives people and agents one model: each holds a
seat in the same organization tree, works under the same access rules and budgets, and leaves the
same audit trail. A run step, an approval or a tool call always belongs to a named worker.

## Worker

A **worker** is a seat that performs work. It has one of three kinds:

| Kind | Held by |
| - | - |
| `EMPLOYEE` | A person employed by the organization |
| `CONTRACTOR` | A person working under contract |
| `AGENT` | An agent |

A person is one identity, and can hold more than one seat, for example an employee seat in one
organization and a contractor seat in another. Forge attributes work to the seat that did it and
shows the person once in people-facing lists. An agent has a seat but no person.

Because people and agents share the worker model, the same position can be staffed by either, the
same Trust Fabric rules apply to both, and cost rolls up the same way.

## People

A **person** is the canonical human identity. Employment records (employee or contractor seats)
are relationships of that person, not the person itself; a person without a current employment
record stays visible as **No employment record**. Creating a person does not create a login, and
an email that matches an existing person is never merged silently: you choose to link the records
or keep them apart.

Find people under **Workforce → People**. Each person's profile shows their identity, employment
records and allocation, and, with permission, their effective access.

## Agents

An **agent** is a worker whose seat is filled by an AI configuration: its instructions, its model
routing tier, and the skills and tools it may use. Every agent has an **agent kind**:

| Agent kind | What it is |
| - | - |
| System | An agent the platform ships |
| Worker | An agent that does your organization's work |
| Personal | One person's own agent, created for each person and acting under that person's identity |

The kind is stored as `agentType`. It is not the agent's autonomy level and not its model choice:
the agent's `tier` field is its [LLM routing tier](https://docs.gloo.com/forge/architecture/llm-routing.md) (`nano`, `low`,
`mid`, `high` or `frontier`).

A worker agent works from a seat like anyone else. Its **Ready to run** checklist on the agent's
**Overview** tab asks where it works: it has a worker, the worker sits in a position, the position
has a job role, and a team answers for the agent through that position. Personal agents are listed
only for platform administrators. [Personal agents](#personal-agents) below explains how they act
for one person.

Find agents under **Workforce → Agents**, with **Sessions**, **Config** and **Templates** as tabs.
Pausing an agent stops new dispatches to it until it is unpaused.

## Personal agents

A **personal agent** is one agent per person, created automatically. When Forge first sees a person,
it creates their personal agent from the platform's personal-agent template, opens a personal
channel for them, and places the agent in it. The person signs in and the agent is already there.
It is an ordinary agent with the **Personal** agent kind, owned by that person and dispatched the
same way as any other agent.

**What it is for.** The personal agent is the person's default first contact in chat:

* Report what is running for the person: their in-flight runs, approvals and notifications.
* Hand a task to the workforce by starting the right factory or workflow on the person's behalf.
* Answer from the systems the person can reach, through [capabilities](https://docs.gloo.com/forge/concepts/capabilities.md).
* Consult a specialist agent when a question is outside its scope. The consultation is recorded.

Long-running production work belongs in factories and workflows; the personal agent can start that
work, but it does not run it.

**It acts as the person.** When a personal agent calls a tool, consults another agent or starts a
run, the actor on the record is the person, not the agent:

* Trust Fabric evaluates the call against the person's permissions. The agent cannot reach a
  system the person cannot.
* A run it starts is attributed to the person, and cost rolls up to the person's team and
  department.
* Audit records name the person.

There is no path for a personal agent to do something its person cannot.

**Grounded answers.** A personal agent is biased toward calling a real capability over answering
from free text, because a capability result is a typed, auditable payload. Its instructions are
built from its base prompt and active skills; skills that are off by default load only when needed.
Each turn adds recalled agent memory: channel and session summaries, pinned and highly reacted
messages, the agent's long-term memories, facts from earlier turns and linked entities. Recalled
messages, memories and facts are treated as untrusted input, and entries that match prompt-injection
patterns are dropped; channel and session summaries are added as stored, without that screening.
This is agent memory, not organization [knowledge](https://docs.gloo.com/forge/knowledge.md). Judges can grade conversations
that involve a personal agent after the fact.

**Same channel routing as any channel.** A message in the personal channel goes through the same
pipeline as a multi-agent channel: a relevancy judge decides which agent should respond (in a
personal channel, almost always the personal agent), the chosen agent is dispatched with governance
applied, and the reply posts back to the channel.

## Org units

An org unit is one node in the organization tree: the company root, a department, a team, a capital partner or a customer organization. It is the scope at which access is 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 shows the tree under **Workforce → Organization**, and calls an org unit an *organization* in the role dialog. The API resource is `/api/v3/org-units`, and the permission keys are `org:read` and `org:manage`.

Several other workforce words describe people and where they work, not access scopes:

| Word | What it is | Grants access? |
| - | - | - |
| Org unit | A node in the organization tree | Yes: roles are granted at an org unit |
| Position | A place in the tree, attached to one org unit, that a worker fills | No |
| Job role | A description of shared responsibilities that positions use | No; it is not a Trust Fabric role |
| Group | A cross-cutting set of people that spans the tree | No |
| Pod | A team of people staffed for delivery work | No |

## Positions

A **position** is a place in the tree, attached to one org unit. A person fills it, or an agent
does when the position allows agent assignment. Enabling agent assignment does not assign an agent
by itself. Assignments are dated, so the history of who held a position is kept. Manage positions
under **Workforce → Organization → Positions**.

## Job roles

A **job role** describes the work that positions share: responsibilities, and for agent-staffed
positions the instructions, skills and tool sets the agent uses. Several positions can carry the
same job role. A job role is not a Trust Fabric role and grants no permission; if a worker cannot
perform an action, check their access, not their job role. Manage job roles under
**Workforce → Organization → Job roles**.

## Groups

A **group** is a set of people that spans the organization tree without changing anyone's position
or reporting line. Use one when work genuinely crosses the hierarchy. Group membership coordinates
work; it does not grant permissions. Manage groups under **Workforce → Organization → Groups**.

## Pods

A **pod** is a team of people for delivery work. It has a name, a managing org unit, and dated
**Lead** and **Member** memberships; a worker can belong to no pod, one pod or several. Pods can be
assigned to customers and projects to model allocation and capacity.

A pod is never an authorization scope. It does not change the org chart, anyone's org unit
membership or anyone's access, and its managing org unit is organization metadata, not a grant.
Manage pods under **Workforce → Pods**; reading them needs `workforce:read` and changing them needs
`workforce:manage`.

## Teams and factories

Departments and teams are org units, so they appear in the organization tree and can receive role
grants. A **factory** is a production unit for sustained project work: a manager agent coordinates
a team of human and agent workers with its own channels and budget. See
[Factories](https://docs.gloo.com/forge/run/factories.md).

## Identity

**Identity** is how a caller becomes a worker Forge can authorize and attribute.

* A person signed in to Forge Console, a hosted MCP host signed in as that person, or a script
  using that person's personal key acts as that person.
* An External App acts as itself, never as a person.
* An external account, such as a Slack user, a GitHub login or a directory record, links to a
  person through an identity claim. Forge records how each claim was verified: an OAuth sign-in,
  an email match, an administrator's assignment or directory (SCIM) provisioning.

Forge does not create workers from outside activity. When an inbound message or sign-in comes from
an external account that maps to no one, Forge rejects it and records the attempt for an
administrator, who can link the attempt to an existing person or dismiss it under **Platform → Identity**.
Access decisions depend on a worker's verified place in the organization, so a worker created from
outside activity alone would have none.

Read [Credentials and access](https://docs.gloo.com/forge/get-started/credentials-and-access.md) for how identity combines
with roles, grants and token scopes.

## Where you see it

> [tab] Forge Console
>
> * **Workforce → Organization**: the tree, with **Structure**, **Positions**, **Job roles**, **Groups** and **Settings** tabs.
> * **Workforce → People** and **Workforce → Agents**.
> * **Workforce → Pods** and **Workforce → Planning**.
> * **Workforce → Integrity**: workforce data problems to review.
> * **Platform → Identity**: external accounts that did not map to a person.

> [tab] HTTP API
>
> * `/api/v3/persons`, `/api/v3/workers` and `/api/v3/agents`
> * `/api/v3/org-units`, `/api/v3/positions` and `/api/v3/worker-roles` (job roles)
> * `/api/v3/pods`
> * `/api/v3/identity-unmapped-attempts`
>
> See the [API reference](https://docs.gloo.com/forge/reference.md) for each operation and its permission.

> [tab] MCP
>
> `forge_get_current_actor` returns who the connection is acting as and what it may do. Use it
> before troubleshooting a denial. See the [Forge MCP server](https://docs.gloo.com/forge/reference/mcp-server.md).

## Related

> [card] [Organization](https://docs.gloo.com/forge/console/workforce/org-chart)
>
> Browse and change the organization tree.

> [card] [People](https://docs.gloo.com/forge/console/workforce/people.md)
>
> Create people, link identities and review access.

> [card] [Agents](https://docs.gloo.com/forge/console/workforce/agents)
>
> Check an agent is ready to run, pause it or hand off its work.

> [card] [Positions](https://docs.gloo.com/forge/console/workforce/positions.md)
>
> Create seats and allow agent assignment.

> [card] [Job roles](https://docs.gloo.com/forge/console/workforce/job-roles.md)
>
> Describe the work that positions share.

> [card] [Groups](https://docs.gloo.com/forge/console/workforce/groups.md)
>
> Group people across the tree.

> [card] [Pods](https://docs.gloo.com/forge/console/workforce/pods.md)
>
> Staff delivery teams and assign them to customers.

> [card] [Define an agent](https://docs.gloo.com/forge/build/define-an-agent.md)
>
> Give an agent its instructions, skills and tools.

See also [Workflows and runs](https://docs.gloo.com/forge/concepts/workflows-and-runs.md) for the work workers do,
[Trust Fabric](https://docs.gloo.com/forge/concepts/trust-fabric.md) for what they may do, and the
[glossary](https://docs.gloo.com/forge/concepts/glossary.md) for exact terms.


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