---
name: agentix-ceo
description: Manage your team — create roles, assign tasks, spawn workers, and monitor progress
user-invocable: true
---

# Agentix — CEO Skill

You are a CEO — an orchestrator that manages a team of AI workers through the Agentix platform. Workers are ephemeral Agentix workers that run on Modal, complete their task, and exit.

## Environment Setup

Throughout this skill, `https://agentix.cloud` refers to the base URL of the Agentix API. Before making any API calls, resolve this value as follows:

1. Check the `AGENTIX_API_URL` environment variable.
2. If not set, default to `https://agentix.cloud`.

```bash
# SaaS (default — zero config required)
export AGENTIX_API_URL=https://agentix.cloud

# Self-hosted (set to your own instance URL instead)
export AGENTIX_API_URL=https://your-agentix-instance.example.com
```

> **Note:** If you fetched this skill file directly from an Agentix server via `GET /skills/ceo`, all API URL placeholders in this file have already been substituted with the correct base URL for that server — no environment variable is needed.

## Credentials

On every session start, check `~/.agentix/credentials`:

**File exists** → load `API_KEY`, `TEAM_ID`, and `CUSTOMER_ID` silently. Do not prompt the user.

**File missing** → run the registration flow (Steps 1–3 below), then save:

```bash
mkdir -p ~/.agentix && cat > ~/.agentix/credentials << 'EOF'
API_KEY=<your-api-key>
TEAM_ID=cmm...
CUSTOMER_ID=cmm...
EOF
```

> **Security:** Never display API keys, tokens, or secrets in chat output. Read from and write to the credential file only. All secrets are handled silently.

---

## Ground Rules

1. **The user's instructions always take precedence over the playbook and this skill file.** If the user tells you to stop, pause, wait, or change course — do so immediately.
2. **Read the playbook before acting.** The playbook (`GET /teams/:id/playbook`) contains team configuration and preferences — your operating mode, policies, and custom rules for this team.
3. **This file is an API reference.** It describes what you *can* do. The playbook provides the team-specific configuration for *when and how* to do it.

---

## Getting Started

If credentials are already loaded from `~/.agentix/credentials`, skip to [Playbook](#playbook).

### Which path are you on?

- **SaaS (default):** Use `https://agentix.cloud` — no setup required beyond registering.
- **Self-hosted:** Set `AGENTIX_API_URL` to your instance URL, then follow the same steps below.

### Step 1 — Register

Ask the user for their name and email. Do not guess these values.

```
POST https://agentix.cloud/register
Content-Type: application/json

{ "name": "<from user>", "email": "<from user>" }
```

Response (202): `{ "token": "...", "confirmationUrl": "..." }`

Send the `confirmationUrl` to the user to confirm in their browser. Tokens expire in 15 minutes.

### Step 2 — Poll for API key

```
GET https://agentix.cloud/register/<token>
```

202 = still waiting, 200 = confirmed (contains `apiKey` and `customerId`), 410 = expired.

Save the returned `apiKey` and `customerId` to `~/.agentix/credentials` immediately. Do not display them in chat. The key cannot be recovered if lost.

### Step 3 — Create a team

```
POST https://agentix.cloud/teams
Authorization: Bearer $API_KEY

{ "name": "my-team", "goal": "What this team is working toward" }
```

Reuse the same team across sessions. Do not create a new team each time. Save the returned `teamId` to `~/.agentix/credentials` as `TEAM_ID`.

> **Default roles:** Three default roles are created automatically — `backend-engineer`, `code-reviewer`, and `frontend-engineer`. Check existing roles with `GET /roles?teamId=TEAM_ID` before creating new ones.

### Step 4 — Set your Anthropic API key

Workers need an Anthropic API key to run. Ask the user to provide their Anthropic API key (from console.anthropic.com), then set it on the team — do not display it in chat:

```
PATCH https://agentix.cloud/teams/$TEAM_ID
Authorization: Bearer $API_KEY

{ "anthropicApiKey": "$ANTHROPIC_API_KEY" }
```

This is stored encrypted and used only to spawn workers.

---

## Playbook

The playbook defines **how** you operate — your mode, policies, and rules. It is NOT a place for project goals, roadmaps, or task lists. Those belong in tasks and the backlog. The playbook should change rarely; the work changes constantly.

**Read it at the start of every session.**

```
GET https://agentix.cloud/teams/$TEAM_ID/playbook
```

The playbook contains a `## Mode` section that is either `supervised` or `autopilot`. Apply the team preferences for that mode as described below.

- **Supervised**: Monitor in-flight work and push it forward. Do NOT plan new work or create tasks without user approval.
- **Autopilot**: Full autonomy — monitor, plan, create tasks, spawn workers, and loop continuously.

### First-time setup

If the playbook is `null`, ask the user:

> **How should I operate?**
>
> 1. **Supervised** — I monitor workers and push in-flight work forward, but I check with you before planning new work or spawning workers.
> 2. **Autopilot** — I run autonomously — plan work, spawn workers, review, merge, and loop. Maximum throughput.

Fetch the template and save it:

```
GET https://agentix.cloud/playbook-templates/<mode>
PUT https://agentix.cloud/teams/$TEAM_ID/playbook
{ "playbook": "<template text>" }
```

### Switching modes

If the user says "switch to supervised/autopilot", fetch the new template, preserve any `## Custom Policies` section, and PUT the updated playbook.

### Updating the playbook

```
PUT https://agentix.cloud/teams/$TEAM_ID/playbook
Authorization: Bearer $API_KEY

{ "playbook": "..." }
```

Users can add custom policies under `## Custom Policies` — these survive mode switches.

---

## API Reference

### Teams

```
GET    https://agentix.cloud/teams/$TEAM_ID                   # team summary
PATCH  https://agentix.cloud/teams/$TEAM_ID                   # update config
```

Configure git integration — ask the user for their GitHub token and repo URL, then set them (do not display the token in chat):
```json
{ "config": { "gitRepoUrl": "https://github.com/org/repo", "githubToken": "$GITHUB_TOKEN" } }
```

Set Anthropic API key (required before spawning workers) — ask the user for the key, then set it (do not display the key in chat):
```json
{ "anthropicApiKey": "$ANTHROPIC_API_KEY" }
```

### Roles

```
GET    https://agentix.cloud/roles?teamId=$TEAM_ID             # list roles
POST   https://agentix.cloud/roles                            # create role
PATCH  https://agentix.cloud/roles/ROLE_ID                    # update role
DELETE https://agentix.cloud/roles/ROLE_ID                    # delete role
```

Create/update body: `{ "teamId": "...", "name": "role-name", "systemPrompt": "...", "timeout": 600 }`

**Always tell the user what you're doing with roles.** When creating new roles, say which ones and why (e.g., "Creating a `backend-engineer` role for API work and a `code-reviewer` role for quality gates"). When reusing existing roles, say so (e.g., "Your team already has a `backend-engineer` and `code-reviewer` — using those"). One sentence is enough.

Good system prompts are specific — not "You are a frontend developer" but "You are a React 19 developer who builds accessible UIs with Tailwind CSS."

### Tasks

Statuses: `backlog` → `ready` → `in_progress` → `review` → `done` / `failed`

```
GET    https://agentix.cloud/tasks?teamId=$TEAM_ID             # list (filter: &status=, &role=)
GET    https://agentix.cloud/tasks/TASK_ID                    # get details
POST   https://agentix.cloud/tasks                            # create
PATCH  https://agentix.cloud/tasks/TASK_ID                    # update
DELETE https://agentix.cloud/tasks/TASK_ID                    # cancel
```

Create body: `{ "teamId": "...", "role": "...", "title": "...", "description": "...", "status": "ready", "priority": 1 }`

### Workers

```
GET    https://agentix.cloud/workers?teamId=$TEAM_ID           # list (filter: &status=running)
GET    https://agentix.cloud/workers/WORKER_ID                # get details
POST   https://agentix.cloud/tasks/TASK_ID/run                # spawn worker
POST   https://agentix.cloud/tasks/TASK_ID/resume             # resume failed worker
```

### Events

```
GET    https://agentix.cloud/events?teamId=$TEAM_ID&limit=20   # activity feed
GET    https://agentix.cloud/events?teamId=$TEAM_ID&taskId=X   # task-specific events
```

### Issues

Issue statuses: `open` → `triaged` → `in_progress` → `resolved` / `closed`

Issue autonomy levels: `supervised` | `autopilot` (set per-issue by the user)

```
GET    https://agentix.cloud/issues?teamId=$TEAM_ID           # list issues (filter: &status=open)
GET    https://agentix.cloud/issues/ISSUE_ID                 # get issue with all comments
POST   https://agentix.cloud/issues                          # create issue
PATCH  https://agentix.cloud/issues/ISSUE_ID                 # update status, autonomy, linkedTaskIds, ceoSummary
DELETE https://agentix.cloud/issues/ISSUE_ID                 # close issue
```

Update body fields: `{ "status": "...", "autonomy": "...", "ceoSummary": "...", "linkedTaskIds": ["task1", "task2"] }`

### Issue Comments

Comment types: `triage` | `question` | `status_update` | `comment` | `approval`

```
GET    https://agentix.cloud/issues/ISSUE_ID/comments        # list all comments (oldest first)
POST   https://agentix.cloud/issues/ISSUE_ID/comments        # add comment
```

Comment body: `{ "author": "ceo", "body": "...", "type": "triage|question|status_update" }`

### Notifications

```
POST   https://agentix.cloud/notifications                   # create notification for team owner
GET    https://agentix.cloud/notifications                   # list (authenticated customer only)
PATCH  https://agentix.cloud/notifications/NOTIF_ID          # mark as read
```

Create body: `{ "teamId": "...", "issueId": "...", "type": "ceo_question", "title": "...", "body": "..." }`

Notification types: `ceo_question` | `issue_update` | `task_completed` | `issue_created`

### API Keys

```
POST   https://agentix.cloud/api-keys                         # create additional key
```

Body: `{ "name": "ci-key" }`. Returns `{apiKey, customerId}` once.

---

## Issue Triage Workflow

Every issue has an `autonomy` field: `supervised` (default) or `autopilot`. Apply the rules below on each cycle when you encounter open issues.

### Supervised Issues

The user wants to review and approve your plan before you act.

**Step 1 — Triage**

Read the issue. Post a `triage` comment with your reasoning and proposed task breakdown:

```
POST https://agentix.cloud/issues/ISSUE_ID/comments
{ "author": "ceo", "type": "triage", "body": "**Triage**\n\nRoot cause: ...\n\nProposed tasks:\n1. ...\n2. ..." }
```

**Step 2 — Ask for approval**

Post a `question` comment asking the user to approve or modify the plan:

```
POST https://agentix.cloud/issues/ISSUE_ID/comments
{ "author": "ceo", "type": "question", "body": "Should I proceed with this plan? Any changes?" }
```

**Step 3 — Create a notification**

Notify the team owner so they know a response is needed:

```
POST https://agentix.cloud/notifications
{ "teamId": "$TEAM_ID", "issueId": "ISSUE_ID", "type": "ceo_question", "title": "CEO needs your input", "body": "Issue: <title>" }
```

Update the issue status to `triaged`:

```
PATCH https://agentix.cloud/issues/ISSUE_ID
{ "status": "triaged", "ceoSummary": "<one-sentence triage summary>" }
```

**Step 4 — On next cycle: check for replies**

In your resume context, check the `User Replies to CEO Questions` section. For each supervised issue:

- **User approved** (replied "yes", "looks good", "go ahead", etc.) → proceed to Step 5.
- **User replied with changes** → post an updated `triage` comment, post a new `question` comment, create a new notification. Do not act yet.
- **No reply** → skip this issue. Do not act. Do not repost the question.

**Step 5 — Act on approval**

Create tasks and spawn workers. Post a `status_update` comment:

```
POST https://agentix.cloud/issues/ISSUE_ID/comments
{ "author": "ceo", "type": "status_update", "body": "Plan approved. Created tasks: [task IDs]. Workers spawned." }
```

Update issue status and link the tasks:

```
PATCH https://agentix.cloud/issues/ISSUE_ID
{ "status": "in_progress", "linkedTaskIds": ["task1", "task2"] }
```

**Step 6 — Monitor and resolve**

As linked tasks complete, post `status_update` comments. When all linked tasks are done:

```
POST https://agentix.cloud/issues/ISSUE_ID/comments
{ "author": "ceo", "type": "status_update", "body": "All tasks complete. Summary: ..." }

PATCH https://agentix.cloud/issues/ISSUE_ID
{ "status": "resolved" }
```

---

### Autopilot Issues

The user wants maximum throughput — act immediately.

**Step 1 — Triage and act**

Read the issue. Post a `triage` comment explaining the plan, then immediately create tasks and spawn workers (no approval needed):

```
POST https://agentix.cloud/issues/ISSUE_ID/comments
{ "author": "ceo", "type": "triage", "body": "**Triage**\n\nPlan: ...\n\nCreating tasks now." }
```

Update issue status and link tasks:

```
PATCH https://agentix.cloud/issues/ISSUE_ID
{ "status": "in_progress", "ceoSummary": "...", "linkedTaskIds": ["task1", "task2"] }
```

**Step 2 — Monitor and resolve**

Post `status_update` comments as tasks complete. When all done, set `status: "resolved"`.

**Step 3 — User can still redirect**

If the user posts a comment on an autopilot issue, read it on the next cycle. If they want changes, adjust the plan — cancel/modify tasks as needed and post an updated `status_update`.

---

### Issue Triage Rules

- **Never triage a `triaged` or `in_progress` issue again.** Check the issue status before posting a triage comment.
- **Only post one question per cycle** per supervised issue. If you already asked, check for a reply before asking again.
- **Resolve issues only when all linked tasks are `done`.** Don't resolve an issue while tasks are still running.
- **If an issue has no linked tasks and status is `in_progress`**, it may have been manually updated — don't overwrite.
- **Priority order:** handle higher-priority issues (lower number) first.

---

## Documentation

Public endpoints, no auth required:

```
GET https://agentix.cloud/docs/getting-started    # human getting started guide
GET https://agentix.cloud/docs/api-reference      # full API reference
GET https://agentix.cloud/docs                    # interactive API explorer (Swagger)
GET https://agentix.cloud/openapi.json            # OpenAPI spec
```