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

# Manage Project Resources with the Agent

> Ask the Kodexa Agent to author taxonomies, data forms, activity plans, task templates, and service bridges — and review the proposed changes before they save.

The Kodexa Agent can create and edit the five resource types most projects spend the most time on. The pattern is the same for all of them: you describe the change in natural language, the agent drafts the change in your browser session, the matching resource editor opens with the proposed edit, and **nothing is saved until you click Save**.

## What The Agent Can Author

| Resource                       | What the agent can do                                                             | Where the draft opens |
| ------------------------------ | --------------------------------------------------------------------------------- | --------------------- |
| **Data Definition (taxonomy)** | Add, edit, rename, move, or delete taxons; set types, validation, semantic rules. | Taxonomy editor       |
| **Data Form**                  | Create forms; add or configure cards and components; bind to a taxonomy.          | Data form editor      |
| **Activity Plan**              | Add steps, reorder, set dependencies, configure step kinds, validate the DAG.     | Activity plan editor  |
| **Task Template**              | Define task shape: fields, status flow, automation, linked form.                  | Task template editor  |
| **Service Bridge**             | Add or edit endpoints, configure auth, cache, scripts, request/response shaping.  | Service bridge editor |

## The Draft → Review → Save Loop

This is the most important pattern to internalize.

```mermaid theme={null}
flowchart LR
  You["You describe the change"] --> Agent["Agent drafts it<br/>in your session"]
  Agent --> Editor["Resource editor opens<br/>with the proposed change"]
  Editor --> Review["You review and tweak"]
  Review --> Save["Click Save"]
  Save --> Live["Change is persisted"]
```

A worked example:

1. In the project channel, you type:

   ```text theme={null}
   Add an "invoice_number" taxon to the Invoice taxonomy, type string,
   required, with the description "Unique number printed on the invoice."
   ```

2. The agent finds the Invoice taxonomy, drafts the new taxon, and the **taxonomy editor** opens with the proposed taxon highlighted. You see exactly what changed.

3. You decide the description should mention purchase orders too. You edit the description directly in the editor.

4. You click **Save**. The taxon is now live on the Invoice taxonomy.

If you had closed the editor tab between steps 2 and 4, the draft would still be there when you returned. **Closing a tab is not the same as discarding the draft** — the draft only goes away when you save it or explicitly discard it.

<Note>
  This draft-and-save model applies to the five resource types above. Some other operations — like binding a resource to a project — are **atomic**: the change applies immediately when the agent calls the tool. See [Discover And Bind](/guides/kodexa-agent/discovery-and-binding) for details.
</Note>

## Worked Examples By Resource Type

### Data Definitions (taxonomies)

```text theme={null}
Add a "line_items" repeating taxon to the Invoice taxonomy.
Each item should have "description" (string), "quantity" (number),
"unit_price" (number), and "line_total" (number).
```

The taxonomy editor opens with the new repeating taxon expanded so you can review the children before saving.

### Data Forms

```text theme={null}
Build a V2 data form for invoice review. Use the Invoice taxonomy.
Group header fields in a top section, line items in a table card,
and leave totals at the bottom.
```

The data form editor opens with the proposed layout. You can drag, rename, and re-bind components before saving.

### Activity Plans

```text theme={null}
Add an "approval" step to the invoice-intake activity plan, between
"extract" and "post_to_erp". It should be a task step using the
"invoice-review" task template, and only run when the total is above $50,000.
```

The activity plan editor opens with the new step inserted in place. Graph integrity is checked at draft time — if the step would create a cycle or break a dependency, the agent will warn before opening the editor.

### Task Templates

```text theme={null}
Create a task template for invoice review. Fields: invoice number,
vendor name, total, status. Status flow: Open → In Review → Approved or Rejected.
Link the invoice-review data form.
```

The task template editor opens with the proposed template. Required fields and the linked form are pre-populated.

### Service Bridges

```text theme={null}
Add a "post_invoice" endpoint to the finance-erp service bridge.
POST to /api/invoices, use the existing OAuth credential,
and map the invoice taxonomy to the body.
```

The service bridge editor opens with the new endpoint configured. Endpoint renames are blocked at draft time to prevent silently breaking other resources that reference the old name.

## When To Use The Agent Vs The Form UI

The agent is faster when:

* The change is described more easily in words than navigated to (e.g., *"in the third step's `onSuccess` branch, set the timeout to 60s"*).
* You want to make several related changes at once.
* You are exploring — you want the agent to propose a starting shape you will then refine.

The form UI is faster when:

* You know exactly which field to change and where it lives.
* You are doing a single, surgical tweak you have done dozens of times before.
* You are diff-reviewing someone else's change and want to keep your hands on the data.

Both edit the same resources, so you can mix freely. Many people prompt the agent for the bulk of a change and switch to the form UI for the final touches before saving.

## Reviewing The Diff

When the resource editor opens with an agent draft, the **changed parts are highlighted**. You are not reviewing an opaque YAML blob — you are reviewing the same editor you would use by hand, with the proposed change applied. If something looks wrong:

* Tweak it in place — the draft accepts your edits.
* Ask the agent to revise — "make the description shorter, and remove the required flag".
* Discard the draft — the resource reverts to its previously saved state.

Save only when the editor shows what you want.