Appearance
Build agents
In DutyGraph, an agent is a manifest: a versioned, hashed description of one agent. DutyGraph proposes it from the Company Repo, a person reviews it, and DutyGraph writes it out for the AI tool the company already uses.
WARNING
DutyGraph does not run agents. A manifest grants no access and holds no credential. The builder says so on every draft: "The draft gives no access."
Four things that stay separate
| Layer | Question | Where it lives today | Status |
|---|---|---|---|
| Agent Definition | What should the agent do? | The Task Cards and the manifest's steps, markers and stop conditions | Built |
| Agent Implementation | What instructions, tools and code make it do that? | The export files formatted for a runtime | Built as files. DutyGraph does not run them. |
| Agent Authorization | What authority does it hold? | A governed request, its approval chain and the ledger | Built for human-delegated agents |
| Agent Execution | What did it actually do? | Activity recorded at the DutyGraph gateway | Built for routed calls only |
A draft gives no authority. Saving a manifest, sharing a plan or exporting files grants nothing. Only the approval chain authorizes, and only the company's IAM provisions.
A material change to an agent's implementation should be checked again against its authorization. Today, manifest freshness marks a saved manifest Out of date or Broken when its sources change. Checking a changed implementation against an issued authorization is Planned.
What a manifest is
A manifest (schema dutygraph.agent-manifest.v1) answers the questions a reviewer asks about an agent:
| Question | What the manifest records |
|---|---|
| Who does it work for? | The person it acts for and the owner, who is accountable |
| What work does it do? | The Task Cards it works from, each pinned by record version and content hash |
| What does it do at each step? | Each step, word for word, marked [A], [S] or [H] |
| What can it touch? | Each system, the person's recorded access, and a policy for each tool |
| Where does it stop? | Human gates, stop conditions and what it must never do |
| Where did each value come from? | A Repo file and line for every filled field, and a hash of the whole manifest |
Every manifest is in the state "proposed". Saving a change makes a new version. See Agent builder and manifests for the full schema.
From opportunity to agent
Step 1
DutyGraph proposes agents
Open Opportunities › Proposed agents. Code reads the Company Repo. No AI call makes a proposal. Code groups Task Cards that have a proposed AI mode by the person who does the work, the owner and the duty.
Each proposal acts for one named person, inside that person's access. A rule can lower the AI mode. One line names the step and the reason, for example "Lower than proposed: step 4 contacts the supplier."
Code also lists what it did not propose, with one reason each, such as "No accountable owner". DutyGraph does not invent authority.
Step 2
The advisor builds the manifest
Select Open template or Open draft. The agent builder opens in Agents › Workspace, already filled from the Repo. The advisor can make a step marker or a tool policy tighter, never looser. Save draft saves a new version.
Step 3
The person checks the plan
Share the plan with <person> creates a private link to a plain plan for the person the agent acts for. They answer This looks right or Something's off. See Share the agent plan.
Step 4
The advisor exports the files
The builder writes five formats: a sheet for people, DutyGraph's manifest JSON, and files formatted for Claude Code, Claude Managed Agents and OpenAI Agents. Each comes with README.md and GAPS.md. See Exports and runtimes.
Step 5
Governance decides the access
Where a company has set up governance, Governed access in the builder shows the agent's access request, or offers Start the access request to the owner. The approval chain decides. IAM issues in DutyGraph and provisions in the company's own systems. The gateway checks calls routed through it. See Govern agents.
Other ways in
- Strategy › Summary: a possible constraint card shows Proposed agents: N → when an agent links to it.
- Work Map › Value chain: with the Automation candidates lens on, select Open in Agents →.
- Work Map › Task Cards: select a Task Card with a proposed AI mode, then Make a manifest →. If code did not propose an agent for it, the page says why.
The Agents tabs
| Tab | What it holds |
|---|---|
| Workspace | The builder, on the last agent you opened |
| Saved agents | Each saved manifest, its version, its freshness and its gaps |
| Requests, Review queue, Issued agents, Rules, Audit | Agent governance. See Govern agents. |
| Business review | Earlier agent requests, manifest drafts and the business review |
What DutyGraph does and does not do
| DutyGraph does | DutyGraph does not |
|---|---|
| Propose agents from the Repo, by code | Invent an owner, an approver or a past case |
| Record the access level a person reports for a role and system | Change access in any business system |
| Write files formatted for an AI tool | Run, host, start or connect the agent |
| Record governance decisions on a hash-linked ledger | Provision the agent identity. The company's IAM does that. |
On Cobalt Industrial Supply (fictional sample), each page shows Sample output · no AI call. Asks and access requests stay on the page and are not sent.
In this section
| Page | What it covers |
|---|---|
| Agent builder and manifests | The builder workspace, markers, tool access, saving, freshness and the manifest schema |
| Share the agent plan | The private plan link for the person the agent acts for |
| Exports and runtimes | Every export format, the runtime check at issue, and what is planned |
| Govern agents | Holdings, rules, the approval chain, the ledger and the gateway |
INFO
Status. Built: proposed agents and Not proposed reasons, the builder, versioned manifests, freshness, the shared plan link and five export formats. Simulated: the sample companies' access values and, in the governance sample, the identity systems and agent runtime. Planned: describing a new agent in words, past cases from people, loading a manifest into an AI tool for the company, running agents on the company's own vendor account, and revalidating an issued authorization when the implementation changes.
Source: gitbook/product/agents/README.md in the DutyGraph repository.