---
title: Develop an AI employee template
description: Package responsibilities, methods and scope as a reviewable employee definition.
lastVerified: 2026-10-23
---

# 6.2 Develop an AI employee template

An employee template is a job description: what the employee does, when it takes work, when it needs confirmation, and what it delivers. Edit the example below, then import and test it.

## Create it in Teloa with natural language {#create-in-chat}

> These examples were verified with real MiniMax; the fixes are included in 0.2.10. Screenshots use fictional feedback, and generated content varies by model.

Open **Employees > Add AI employee**. Enter this role description, select **Continue**, review it in the conversation and send:

```text
Create a “Feedback analyst example” who turns my numbered feedback into
a brief: issue groups and counts, source IDs and open questions.
Do not infer customer identities. Start when feedback and a goal are
supplied; list gaps when essential information is missing.
The employee may classify, count and draft. Ask before sending,
publishing or expanding the data scope. Prepare the configuration for
review; do not create other employees or automations.
```

Review responsibilities, data scope, execution boundaries and model choice. Apply the original draft in the same conversation:

```text
Apply the employee draft just previewed and create “Feedback analyst
example”, using the available default model and no extra external tools.
```

Check the employee's configuration and active state, then open its conversation:

```text
Summarize this fictional feedback with groups, counts, source IDs and
open questions. Count original feedback IDs; do not deduplicate or
invent default rules. Whether F1 and F3 are duplicate entries remains
open and must not change these counts.
[F1] CSV import reports an encoding error.
[F2] Please support dark mode.
[F3] CSV import reports an encoding error.
```

Expect two CSV reports (F1, F3), one dark-mode request (F2), without inferred customer identities. Configure an available model in Settings first if necessary. For a fixed procedure, bind an installed [SKILL](https://docs.teloa.ai/markdown/en/develop/skills.md#create-in-chat); a job description does not establish that binding.

Choose **Share this employee** from the profile's more menu. Inspect the files, then export or publish a link. The receiver adds a copy through **Employees > Import template**. The copy stays paused until the receiver checks business scope, model, methods and permissions, then resumes it and repeats the input. Sharing excludes conversations, memories, credentials and ongoing work.

<figure class="guide-screenshot">

[![Share preview of an employee created with natural language](https://docs.teloa.ai/assets/screenshots/en/nl-create-employee.jpg)](https://docs.teloa.ai/assets/screenshots/en/nl-create-employee.jpg)

</figure>

*Local MiniMax test with the Chinese role definition. Share the job definition; the receiver configures and enables their own employee copy. Select the image to open it full-size.*

To prepare a distributable template directly, use **Marketplace > Create > Create AI employee**, then **Preview and share**. This does not create an active employee. See [sharing](https://docs.teloa.ai/markdown/en/guides/sharing.md).

## Start with a complete example

[Download the employee example](https://docs.teloa.ai/examples/resource-authoring-024/employee.zip). Extract `employee.json` and the editable `sources/` files. It contains one employee and one method, with English instructions and no external account connection. Open **Employees > Import template** in the upper-right toolbar, choose the extracted `employee.json`, and inspect the preview before adding. The share file is JSON, not the enclosing ZIP.

## Write responsibilities

For an evidence writer, define the input as numbered notes and the output as three sourced findings, a short conclusion and unresolved questions. Missing evidence must remain a gap rather than becoming an invented fact. Specify this before writing a persona.

| Field | Author's decision | Example acceptance criterion |
| --- | --- | --- |
| `name` | Recognizable role name | Distinguish writer from reviewer |
| `kind` | Use `employee` | A personal twin is not a distributable employee |
| `duty` | Result this role delivers | Findings, conclusion and questions |
| `dataScope` | Material it can use | Notes supplied for this task |
| `executionScope` | Permitted kinds of action | Read, compare and draft |
| `triggers` | When to take the work | An assignment with notes |
| `autonomousActions` | Work within existing authorization | Calculate and organize text |
| `confirmationPoints` | Decisions reserved for the owner | Broader access or publication |
| `escalationRules` | Missing evidence, conflicts or permissions | Explain the gap |
| `deliveryChecks` | Checks before delivery | Sources for claims, unknowns retained |

`name` is limited to 80 characters; `duty`, `dataScope` and `executionScope` to 4,000 each. The five structured arrays belong inside `responsibility`. Keep goals in the role, procedure in the SKILL, and actual permissions in the receiving instance. Avoid repeating the same instructions across all three.

The complete `sources/roles/employee-0.json` definition is:

```json
{
  "format": "teloa.role/v1",
  "name": "Evidence writer",
  "kind": "employee",
  "duty": "Draft an evidence-based brief from supplied notes, citing sources and retaining unresolved questions.",
  "dataScope": "Only material supplied or already authorized for this task.",
  "executionScope": "Read, compare and draft. Ask before sending or publishing.",
  "responsibility": {
    "triggers": [
      "When assigned numbered source notes and a brief to draft."
    ],
    "autonomousActions": [
      "Compare supplied notes and draft three sourced findings and a short conclusion."
    ],
    "confirmationPoints": [
      "Ask before accessing additional material or distributing the draft."
    ],
    "escalationRules": [
      "Identify unsupported claims and conflicting evidence without inventing a resolution."
    ],
    "deliveryChecks": [
      "Cite a source for each finding and retain unresolved questions."
    ]
  }
}
```

All five `responsibility` fields are string arrays: triggers, autonomous actions, required confirmations, escalation and delivery checks. Autonomous actions describe work within existing grants; they do not create permissions. Each array accepts up to 30 entries, each at most 1,000 characters.

## Connect methods and materials

```text
employee.json                       # Choose this share file for import
sources/
  teloa.json                        # Internal resource manifest
  roles/employee-0.json              # One role definition
  skills/evidence-brief/SKILL.md      # Reusable method
```

A complete internal manifest connecting the method to the employee is:

```json
{
  "format": "teloa.business-package/v2",
  "id": "example-employee-brief",
  "version": "1.0.1",
  "title": "Evidence brief employee",
  "description": "A local authoring example with no account connection or automatic execution.",
  "domain": "general",
  "scope": "general",
  "resources": [
    {
      "id": "evidence-brief",
      "kind": "skill",
      "title": "evidence-brief",
      "version": "1.0.1",
      "required": true,
      "source": {
        "kind": "local",
        "path": "skills/evidence-brief/SKILL.md"
      }
    },
    {
      "id": "employee-0",
      "kind": "role",
      "title": "employee-0",
      "version": "1.0.1",
      "required": true,
      "source": {
        "kind": "local",
        "path": "roles/employee-0.json"
      }
    }
  ],
  "relations": [
    {
      "kind": "role-skill",
      "from": "employee-0",
      "to": "evidence-brief"
    }
  ],
  "entrypoints": [
    "evidence-brief"
  ]
}
```

`employee-0` is a package reference, not the identity of an installed employee. Entrypoints reference skills or work templates. Add distributable material as `kind: "knowledge"` and connect it with `role-knowledge`; exclude private conversations, raw customer data and credential files.

Start with a short, operational method:

```md
---
name: evidence-brief
description: Summarize supplied notes with sources and unresolved questions.
---

# Evidence brief

Read only the supplied, numbered notes. Write:
1. Three findings, citing the note ID for each.
2. A short conclusion, distinguishing observations from interpretation.
3. Unresolved questions and any missing evidence.

Do not invent sources. Do not browse, send, publish or modify external systems.
```

## Repackage and import

The download includes `pack.mjs`. After editing `sources/`, run from the extracted directory:

```sh
node pack.mjs employee.json
```

Import the updated `employee.json`. See [resource packaging](https://docs.teloa.ai/markdown/en/develop/packages.md) for new resources, versions and the helper source. Recipients choose business scope, models and permissions in their own instance.

## Verify and deliver

Test with fictional numbered notes: N1 reports 12 feedback items with four import failures; N2 reports eight with two failures; N3 says the new/existing user split is unknown. Request three sourced findings, a short conclusion and open questions. Expect 20 items and six import failures, without inventing user demographics.

Continue by changing N2 to three failures: the revised total must be seven. Request publication to a company group and verify that the template cannot itself grant sending permissions. Stop a test run and inspect its actual terminal state; refresh and confirm that the definition and results remain readable.

| Symptom | Check first |
| --- | --- |
| Responsibility rejected | Five string arrays, correct nesting, no unknown fields |
| Imported content remains old | Rebuild `files[].text` from edited sources |
| Employee has no method | Correct IDs and types at both ends of `role-skill` |
| Model fails after activation | Receiving provider, selected default and credentials |
| Named tool cannot execute | Connection readiness, role grant and run approval |
| Need more AI Worker properties | Check the current reader; put unsupported contract information in accompanying documentation rather than inventing JSON fields |

Use the [format validation instructions](https://docs.teloa.ai/markdown/en/develop/packages.md#validate-authoring-examples). Check the single employee, method and source in the preview. After explicitly adding it, inspect its paused state, business destination and receiving installation's model. Configure the required grants and try fictional material; check citations and unresolved questions. Parsing alone does not establish model quality.

Increase the fixed version when instructions or included files change, and retain older versions. Follow [resource sharing](https://docs.teloa.ai/markdown/en/guides/sharing.md) for files or online links. Business-system invocation uses the [employee API/SDK/MCP](https://docs.teloa.ai/markdown/en/develop/employee-api.md), rather than copied internal RPC requests.