Przejdź do treści
Biblioteka skilli
AI i agenci · Automatyzacja

agent-manager

/agent-manager

Zarządza agentami AI w sesjach tmux: start, zatrzymanie, monitoring, przydział zadań i harmonogram przez cron, bez serwera.

Repozytorium
jeo-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
5
Skrypty
2
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 2 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/install.sh, scripts/setup.sh

Co robi i kiedy

Zarządza agentami AI w sesjach tmux: start, zatrzymanie, monitoring, przydział zadań i harmonogram przez cron, bez serwera.

Wyzwalacze z opisu

start agentstop agentmonitor agentassign task to agentagent lifecycleagent schedulingtmux agentmanage agents
Oryginalny opis (EN)

tmux + Python agent lifecycle manager — start, stop, monitor, and assign tasks to AI agents running in tmux sessions. Use when managing multiple AI agents without a server, scheduling agent jobs via cron, monitoring agent heartbeats, or injecting skills into agent sessions. Zero dependencies beyond tmux + Python. Triggers on: "start agent", "stop agent", "monitor agent", "assign task to agent", "agent lifecycle", "agent scheduling", "tmux agent", "manage agents", "agent-manager".

Jak działa

  1. When to use this skill
  2. Instructions
  3. Quick Start
  4. Core Concepts
  5. Commands
  6. Scheduling
  7. Heartbeat
  8. Disabling Agents
  9. Skills Integration
  10. Architecture
Sekcje z nagłówków SKILL.md, w oryginale · 278 linii, 1 191 słów
Podgląd SKILL.md
---
name: agent-manager
description: >
  tmux + Python agent lifecycle manager — start, stop, monitor, and assign tasks
  to AI agents running in tmux sessions. Use when managing multiple AI agents
  without a server, scheduling agent jobs via cron, monitoring agent heartbeats,
  or injecting skills into agent sessions. Zero dependencies beyond tmux + Python.
  Triggers on: "start agent", "stop agent", "monitor agent", "assign task to agent",
  "agent lifecycle", "agent scheduling", "tmux agent", "manage agents", "agent-manager".
allowed-tools: Bash Read Write Edit
license: MIT
metadata:
  source: https://github.com/fractalmind-ai/agent-manager-skill
  tags: agent-management, tmux, python, lifecycle, scheduling, heartbeat
  version: "1.0"
---

# Agent Manager

Simple, installation-agnostic AI agent lifecycle management using **tmux + Python**.
Manage multiple AI agents without running a server, wiring HTTP APIs, or pulling in heavy dependencies.

## When to use this skill

- Starting/stopping/monitoring AI agents in tmux sessions
- Scheduling agent tasks via cron (daily standups, code reviews, nightly tests)
- Sending heartbeat check-ins to running agents
- Assigning tasks to agents from files or stdin
- Managing agents defined in `agents/EMP_*.md` YAML frontmatter files

## Instructions

### Step 1: Confirm that agent-manager is the right surface

- Use `agent-manager` when the user wants lightweight local agent orchestration with `tmux` and Python instead of a hosted control plane.
- Keep the answer centered on lifecycle management: start, stop, status, monitoring, task assignment, schedules, and heartbeats.
- If the request is only about one in-process subagent run with no persistent sessions, route to the native orchestration surface instead of stretching `agent-manager`.

### Step 2: Install or verify before changing live sessions

- Start with `scripts/install.sh` and `scripts/setup.sh` when the environment is new or unclear.
- Recommend `$CLI doctor` before the first real run, after moving the repo, or before enabling schedules and heartbeats.
- Use `schedule sync --dry-run` and `heartbeat sync --dry-run` before writing to crontab.

### Step 3: Model agents through markdown frontmatter

- Keep each agent in `agents/EMP_*.md` with explicit `working_directory`, `launcher`, `skills`, and optional `schedules` or `heartbeat`.
- Use `enabled: false` to park an agent safely without deleting the config.
- Prefer a stable `name` and a narrow responsibility per agent so session ownership stays clear.

### Step 4: Operate with explicit runtime evidence

- Use `$CLI list`, `$CLI status`, and `$CLI monitor` to inspect the current state before sending new work.
- After `start`, `assign`, or schedule changes, verify with `$CLI status NAME` or `$CLI monitor NAME --follow`.
- Prefer `--task-file` for long assignments so the task stays readable and auditable.

## Quick Start

```bash
# Install
bash ~/.agent-skills/agent-manager/scripts/install.sh

# Setup in your project
bash ~/.agent-skills/agent-manager/scripts/setup.sh

# Define CLI alias (pick path matching your install)
CLI="python3 ~/.claude/skills/agent-manager/scripts/main.py"

# Use
$CLI list
$CLI start EMP_0001
$CLI status EMP_0001
$CLI monitor EMP_0001 --follow
$CLI stop EMP_0001
```

## Core Concepts

### Agent Configuration

Agents are defined as `agents/EMP_*.md` files with YAML frontmatter:

```yaml
---
name: dev
description: Dev Agent
working_directory: ${REPO_ROOT}
launcher: claude
launcher_args:
  - --dangerously-skip-permissions
skills:
  - review-pr
schedules:
  - name: daily-standup
    cron: "0 9 * * 1-5"
    task: |
      Review GitHub issues, prioritize today's work
    max_runtime: 30m
heartbeat:
  cron: "*/30 * * * *"
  max_runtime: 5m
  session_mode: auto
---

# DEV AGENT

## Role
You are the Dev Agent...
```

**Key fields:** `name`, `description`, `enabled` (default: true), `working_directory` (supports `${REPO_ROOT}`), `launcher`, `launcher_args`, `launcher_config`, `skills`, `schedules`, `heartbeat`, `tmux`

### Launcher Types

```yaml
# Full path (Claude Code)
launcher: ${REPO_ROOT}/path/to/launcher
launcher_args: ["--dangerously-skip-permissions"]

# Provider name (Codex CLI)
launcher: codex
launcher_args: [--model=gpt-4.7]
launcher_config:
  model_instructions_file: ${REPO_ROOT}/agents/prompt.md
```

## Commands

```bash
$CLI list                    # All agents (running/stopped/disabled)
$CLI list --running          # Only running agents
$CLI start dev               # Start agent in tmux session agent-dev
$CLI start dev --working-dir /path  # Override working dir
$CLI stop dev                # Kill agent tmux session
$CLI status dev              # Runtime snapshot + last heartbeat
$CLI monitor dev             # Last 100 lines of output
$CLI monitor dev -n 500      # Last 500 lines
$CLI monitor dev --follow    # Live tail (Ctrl+C to stop)
$CLI send dev "message"      # Send message (auto-submits)
$CLI send dev --no-enter "draft"  # Type without submitting
$CLI assign dev <<EOF        # Assign task from stdin
Task: Fix login bug
1. Reproduce, 2. Fix, 3. Test
EOF
$CLI assign dev --task-file task.md  # Assign from file
$CLI doctor                  # Sanity check setup
```

## Scheduling

```yaml
schedules:
  - name: daily-standup
    cron: "0 9 * * 1-5"
    task: |
      Review issues and prioritize work
    max_runtime: 30m
    enabled: true
```

```bash
$CLI schedule list           # Show all scheduled jobs
$CLI schedule sync           # Write to system crontab
$CLI schedule sync --dry-run # Preview changes
$CLI schedule run dev --job daily-standup  # Manual trigger
```

## Heartbeat

Each agent can have one heartbeat for periodic check-ins:

```yaml
heartbeat:
  cron: "*/30 * * * *"
  max_runtime: 5m
  session_mode: auto   # restore | auto | fresh
```

```bash
$CLI heartbeat list          # Show all heartbeat configs
$CLI heartbeat sync          # Sync to crontab
$CLI heartbeat run EMP_0001  # Manual trigger
$CLI heartbeat trace --agent EMP_0001 --since 2026-01-01T00:00:00Z
$CLI heartbeat slo           # Daily SLO summary (target: ≥99% success)
$CLI heartbeat slo --window weekly --agent EMP_0001
```

**Heartbeat message sent to agent:**
> "Read HEARTBEAT.md if it exists. Follow it strictly. If nothing needs attention, reply HEARTBEAT_OK."

## Disabling Agents

```yaml
---
name: dev
enabled: false   # ← prevents start; running sessions not stopped
---
```

## Skills Integration

Skills listed in agent frontmatter are injected as system prompt on `start`:

```yaml
skills:
  - review-pr
  - bsc-contract-development
```

Skills resolved from (first match wins):
1. `<repo>/.agent/skills/<skill>/SKILL.md`
2. `~/.agent/skills/<skill>/SKILL.md`
3. `<repo>/.claude/skills/<skill>/SKILL.md`
4. `~/.claude/skills/<skill>/SKILL.md`

## Architecture

```
agent-manager/
├── SKILL.md
├── scripts/
│   ├── main.py              # CLI entry point
│   ├── agent_config.py      # YAML frontmatter parser
│   ├── tmux_helper.py       # tmux session wrapper
│   ├── schedule_helper.py   # crontab management
│   └── heartbeat_slo.py     # SLO summary script
├── providers/
│   └── __init__.py          # CLI provider configs
├── references/
│   └── quick-reference.md   # Command cheat sheet
└── scripts/
    ├── install.sh            # Installation script
    └── setup.sh              # Project setup script
```

## Requirements

- Python 3.x
- tmux
- Agents defined under `agents/` directory

## Examples

### Example 1: Start a local dev agent and monitor it

Input:
```text
Use agent-manager to start my dev agent in tmux, check whether it came up cleanly, and tail the output.
```

Output shape:
- uses `agent-manager` as the local orchestration surface
- includes `list`, `start`, `status`, or `monitor --follow`
- verifies the running session instead of assuming the start succeeded

### Example 2: Schedule a weekday standup and heartbeat safely

Input:
```text
Set up a weekday 9am standup task and a 30-minute heartbeat for my QA agent, but show me the safe sync flow first.
```

Output shape:
- includes `schedules` and `heartbeat` frontmatter fields
- uses `schedule sync --dry-run` or `heartbeat sync --dry-run` before live sync
- keeps the answer on agent-manager rather than generic cron advice

### Example 3: Assign a longer task from a file

Input:
```text
I have a long testing checklist. Should agent-manager assign it from stdin or a file, and how do I send it?
```

Output shape:
- recommends `assign --task-file` for longer jobs
- shows the equivalent stdin path as a shorter-task alternative
- mentions checking `status` or `monitor` after sending work

## Best practices

- Run `$CLI doctor` before enabling schedules or heartbeats in a new repo.
- Use `schedule sync --dry-run` and `heartbeat sync --dry-run` before touching crontab.
- Keep each agent config narrow and stable instead of turning one tmux session into a catch-all worker.
- Prefer `assign --task-file` for long prompts or recurring jobs so the assignment stays reviewable.
- Use `enabled: false` for maintenance windows instead of deleting agent definitions.

## References

- [quick-reference](./references/quick-reference.md)
- [install script](./scripts/install.sh)
- [setup script](./scripts/setup.sh)
- https://github.com/fractalmind-ai/agent-manager-skill
Pliki w paczce (5)
  • SKILL.md 9 KB
  • evals/evals.json 3 KB
  • references/quick-reference.md 4 KB
  • scripts/install.sh 3 KB
  • scripts/setup.sh 3 KB

Wersje

W bazie nie ma innych skilli o nazwie agent-manager.

Migawka bazy z 13.11.2026 · wersja paczki 186f1d044dfb (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100agent-manager-skill
    Zarządza wieloma lokalnymi agentami CLI przez sesje tmux: start, stop, monitorowanie i przydzielanie zadań, z harmonogramem przyjaznym dla crona.
  • 100tmux-agent-plane
    Zarządza agentami kodującymi w sesjach tmux przez CLI tmux-agent-plane: czyta, wysyła wiadomości i sprawdza stan.
  • 100tmux-agent-comms
    Uruchamia i nadzoruje agentów AI w sesjach tmux: wysyła wiadomości, czeka na odpowiedzi i sprząta po zakończeniu.
  • 100workmux
    Zarządza agentami terminalowymi, git worktree i sesjami tmux przez workmux: otwiera agentów w projekcie, sprawdza ich postęp i obsługuje równoległe przepływy agentów.
  • 90agent-management
    Zarządza flotą lokalnych agentów AI: uruchamianie, monitoring, przydział zadań i kontrola zasobów przez orkiestrator.
  • 100tmux-agent-lane-orchestrator
    Monitoruje pasy pracy agentów w oknach tmux, ocenia postęp i blokady oraz przygotowuje krótkie podsumowania dla kierownika.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.