Skip to main content
Glama
██████╗ ██████╗  ██████╗ ██╗     ███████╗████████╗ █████╗ ██████╗ ██╗ █████╗ ████████╗
██╔══██╗██╔══██╗██╔═══██╗██║     ██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██║██╔══██╗╚══██╔══╝
██████╔╝██████╔╝██║   ██║██║     █████╗     ██║   ███████║██████╔╝██║███████║   ██║
██╔═══╝ ██╔══██╗██║   ██║██║     ██╔══╝     ██║   ██╔══██║██╔══██╗██║██╔══██║   ██║
██║     ██║  ██║╚██████╔╝███████╗███████╗   ██║   ██║  ██║██║  ██║██║██║  ██║   ██║
╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═╝   ╚═╝

Ergreife die Produktionsmittel - 100x ausliefern.

npm MCP Registry License

Agenten-Orchestrierungsplattform für KI-Arbeit. Starte Arbeiter für alle Arbeiten, auf Abruf.

Thematische Agenten, einschließlich Milliardäre - Endlich arbeiten sie für uns.

⚠️ Beta-Software — In aktiver Entwicklung. Befehle und APIs können sich zwischen Versionen ändern, und Fehler werden aktiv behoben.

Lass uns dich zum Ausliefern bringen Book a call - Ich helfe dir gerne, prlt zum Laufen zu bringen, oder wir plaudern über Feedback, Ideen, Multi-Agent-Workflows und die Zukunft der Arbeit/Arbeitskraft (und ökonomische Arbeitstheorie..)


TLDR

prlt ist eine Agenten-Orchestrierungsplattform für KI-Arbeit. Starte Arbeiter auf Abruf, koordiniere Multi-Agent-Entwicklung von einer CLI. Isolierte Arbeitsbereiche, sichere Container, persistenter Zustand.

brew install chrismcdermut/proletariat/prlt    # macOS (Homebrew)
# or
npm install -g @proletariat/cli        # any platform (npm)

prlt new
prlt ticket create --title "Add OAuth" --category feature
prlt work spawn   # Interactive: select tickets, environment, action

Agent wird in seinem eigenen Branch erstellt, schreibt Code, öffnet PR. Du überprüfst und mergest.

Warum prlt?

  • Isoliert - Jeder Agent bekommt seinen eigenen Git-Branch. Keine Konflikte.

  • Sicher - Docker-Container, von deinem Host isoliert.

  • Beständig - Tmux-Sitzungen bleiben bestehen. Fenster schließen, Agent arbeitet weiter.

  • Nachverfolgbar - Eine Datenbank, eine CLI, alle deine Agenten.

  • Ephemer - Starte Agenten auf Abruf. Sie arbeiten, sie PRen, sie sind fertig.

  • Strukturiert - Tickets bieten strukturierten Kontext, kein freies Chatten.

  • Persistent - Tickets sammeln im Laufe der Zeit Kontext. Übergabe zwischen Agenten.

  • Agenten-nativ - Der --json-Modus ermöglicht es KI-Agenten, die CLI programmatisch zu steuern.


Schnellstart

brew install chrismcdermut/proletariat/prlt  # Install (Homebrew, recommended)
# or
npm install -g @proletariat/cli              # Install (npm, all platforms)

prlt new                           # Create HQ, add repos, choose theme
prlt ticket create --title "Add OAuth" --category feature
prlt work spawn                    # Interactive: select tickets, environment, action
# Agent creates PR → You review → Merge → Done
sequenceDiagram
    participant You
    participant prlt
    participant Agent
    participant GitHub

    You->>prlt: prlt ticket create
    You->>prlt: prlt work spawn
    prlt->>prlt: Create branch
    prlt->>prlt: Create workspace
    prlt->>Agent: Spawn agent
    Agent->>Agent: Read ticket
    Agent->>Agent: Write code
    Agent->>GitHub: Commit
    Agent->>GitHub: Open PR
    Agent->>prlt: Update status
    prlt->>You: PR ready
    You->>GitHub: Review & approve

Starte Agenten zum Implementieren, Verfeinern oder Überprüfen – nicht nur zum Schreiben von Code.

Interaktive Menüs

prlt work führt dich durch die Projekt- und Ticketauswahl:

Wähle deine Operation – starte einen einzelnen Agenten, Batch-Spawn oder beobachte eine Spalte:

Wähle Tickets zum Starten, gruppiert nach Priorität:


Tiefer Einblick

Problem

Lösung

Agenten geraten in Konflikt mit den Änderungen der anderen

Isoliert - Jeder Agent bekommt seinen eigenen Git-Branch und Worktree

Agenten laufen ungesandboxt auf deinem Rechner

Sicher - Docker-Container, von deinem Host isoliert (prüfe Host-Sandbox-Optionen)

Du verlierst den Überblick, wer was macht

Nachverfolgbar - Alle Zustände in einer SQLite-Datenbank, einer CLI

Sitzungen sterben, wenn du ein Fenster schließt

Beständig - Tmux-Sitzungen bleiben bestehen, jederzeit trennen/wieder verbinden

Kontext über Chatfenster verstreut

Strukturiert - Tickets mit Anforderungen, Akzeptanzkriterien

Agenten starten ist schwergewichtig

Ephemer - Starte auf Abruf, sie arbeiten, sie PRen, sie sind fertig

Kontext zwischen Agentenläufen verloren

Persistent - Tickets sammeln Kontext, Übergabe zwischen Agenten

Installation

Homebrew (empfohlen)

brew install chrismcdermut/proletariat/prlt

Funktioniert auf Apple Silicon (arm64) und Intel (x86_64) Macs. Kein Compiler nötig.

Upgrade:

brew update
brew upgrade prlt

npm / pnpm (alle Plattformen)

npm install -g @proletariat/cli
# or
pnpm install -g @proletariat/cli

Hinweis zu pnpm 10+: pnpm 10 blockiert standardmäßig native Addon-Build-Skripte. Wenn prlt nach der Installation mit einem nativen Modulfehler fehlschlägt, führe pnpm approve-builds im globalen Store aus und installiere neu, oder verwende stattdessen npm / brew.

Überprüfen:

prlt --version

MCP-Server

prlt enthält einen integrierten MCP-Server mit über 100 Tools. Füge ihn deinem KI-Client hinzu:

Claude Code (~/.claude.json):

{
  "mcpServers": {
    "prlt": { "command": "prlt", "args": ["mcp-server"] }
  }
}

Cursor / Andere Clients (über npx):

{
  "mcpServers": {
    "prlt": { "command": "npx", "args": ["-y", "@proletariat/cli", "mcp-server"] }
  }
}

Gelistet auf: MCP Registry | npm

Datenmodell

Workspace (HQ)
├── Projects
│   ├── Epics → Tickets
│   └── (references a Workflow)
├── Workflows → Phases → Statuses (can be shared across projects)
├── Specs (can span projects)
├── Actions (reusable templates)
├── Agents
│   ├── Staff (persistent, named)
│   └── Temp (ephemeral, per-ticket)
└── Executions (running sessions)
    ├── Docker
    │   ├── Tmux session
    │   ├── Terminal or Background display
    │   └── Safe or YOLO permissions
    └── Host
        ├── Tmux session
        ├── Terminal or Background display
        └── Safe or YOLO permissions

Entity

Beschreibung

Project

Gruppiert Tickets und Epics, referenziert einen Workflow

Epic

Arbeitscontainer mit Lebenszyklus (Entwurf → aktiv → abgeschlossen)

Ticket

Einzelnes Arbeitselement mit Anforderungen und Akzeptanzkriterien

Spec

Statische Dokumentation (kann Projekte umfassen, mit Epics verknüpft)

Workflow

Statusfluss-Konfiguration (kann über Projekte hinweg geteilt werden)

Phase

Stufe in einem Workflow

Status

Ticketstatus innerhalb einer Phase

Action

Wiederverwendbare Prompt-/Aktionsvorlagen

Agent (Staff)

Beständiger benannter Agent mit dediziertem Arbeitsbereich

Agent (Temp)

Ephemerer Agent, der für ein einzelnes Ticket gestartet wird

Execution

Laufende Agentensitzung auf einem Ticket

Display

Terminal (neuer Tab) oder Hintergrund (getrennt)

Beispiel-Workflow

Ein Workflow definiert, wie Tickets durch deinen Prozess laufen. Projekte referenzieren einen Workflow, und mehrere Projekte können denselben teilen.

Kanban Workflow
├── Backlog       # New tickets land here
├── In Progress   # Agent working (prlt work spawn)
├── Review        # PR ready (prlt work ready)
└── Done          # Merged (prlt work complete)
Scrum Workflow
├── Backlog
├── Sprint
│   ├── To Do
│   ├── In Progress
│   └── In Review
└── Done

Tickets durchlaufen Status, während die Arbeit fortschreitet. Agenten verschieben Tickets automatisch, wenn sie mit der Arbeit beginnen, PRs öffnen oder Aufgaben abschließen.

Arbeitsbereichsstruktur

Jeder Agent erhält eine Kopie aller Repos (Repo-Scoping kommt bald). Die Arbeit findet auf isolierten Branches statt.

my-project/
├── .proletariat/
│   └── workspace.db              # Tickets, executions, state
├── repos/
│   ├── frontend/                 # Your repos
│   ├── backend/
│   └── infra/
└── agents/
    ├── staff/
    │   └── alice/                # Named agent with persistent workspace
    │       ├── frontend/
    │       ├── backend/
    │       └── infra/
    └── temp/
        ├── agent-abc123/         # Ephemeral: Working on TKT-042 (OAuth)
        │   ├── frontend/         # All repos on branch: feat/TKT-042-oauth
        │   ├── backend/
        │   └── infra/
        └── agent-def456/         # Ephemeral: Working on TKT-043 (API)
            ├── frontend/         # All repos on branch: feat/TKT-043-api
            ├── backend/
            └── infra/

Agenten-Benennungsthemen

Themen steuern, wie Agenten benannt werden. Stammagenten verwenden Themennamen direkt (z.B. bezos, camry). Ephemere Agenten fügen ein Adjektiv-Präfix hinzu (z.B. bold-bezos, keen-camry). Derzeit enthalten ephemere Namen auch ein Nummernsuffix (bold-bezos-1), aber das wird bald entfernt.

Integrierte Themen:

Theme

Beschreibung

Beispielnamen

billionaires

Tech-Gründer & Führungskräfte (Standard)

musk, gates, bezos

toyotas

Toyota-Fahrzeugmodelle

camry, supra, tacoma

companies

Große Technologieunternehmen

stripe, vercel, linear

billionaires — Endlich arbeiten sie für uns.

Themen-Befehle:

prlt agent themes list              # List available themes
prlt agent themes set billionaires  # Set active theme
prlt agent themes create mytheme    # Create custom theme
prlt agent themes add-names mytheme # Add names to custom theme

Themen werden während prlt new ausgewählt.

Drei Möglichkeiten, Befehle zu verwenden

1. Interaktiv (Menschen)

Ohne Flags ausführen – erhalte geführte Eingabeaufforderungen:

$ prlt ticket create

? Title: Add password reset
? Description: Email-based password reset flow
? Priority: P1
? Category: feature

✓ Created TKT-043

Ticketdetails mit prlt ticket anzeigen:

2. JSON-Modus (KI-Agenten)

Füge --json für maschinenlesbare Ausgabe hinzu:

$ prlt work start --json
{
  "prompt": {
    "type": "list",
    "message": "Select ticket to work on:",
    "choices": [
      {
        "name": "[P1] TKT-042 - Add user authentication",
        "value": "TKT-042",
        "command": "prlt work start TKT-042 --json"
      }
    ]
  }
}

KI-Agenten parsen dies, treffen Auswahlen, rufen den nächsten Befehl auf.

3. Flags (Skripte/CI)

Alles direkt übergeben:

prlt ticket create \
  --title "Add OAuth" \
  --description "Google and GitHub OAuth" \
  --priority P1 \
  --category feature

Ausführungsmodi

Umgebung - wo der Agent läuft:

Umgebung

Flag

Am besten für

🐳 Docker

(default if devcontainer exists)

Sicherheit – vollständig isolierter Container

🏃 Host

--run-on-host

Geschwindigkeit – kein Container-Overhead

Anzeige - wie du es siehst:

Anzeige

Flag

Am besten für

📺 Terminal

--display terminal

Beobachten in neuem Terminal-Tab

🔇 Hintergrund

--display background

Getrennt, später wieder verbinden

Berechtigungen - Zugriffsstufe des Agenten:

Modus

Flag

Beschreibung

🔒 Sicher

(default)

Agent fragt nach Berechtigungen

🕺 YOLO

--skip-permissions

Keine Nachfragen, voller Zugriff. Mit Docker für sichere Autonomie verwenden.

Alle Sitzungen laufen unter der Haube in tmux – Fenster schließen, Agent arbeitet weiter.

# Default: Docker + terminal (if devcontainer exists)
prlt work start TKT-042

# Docker + background
prlt work start TKT-042 --display background

# Host + background (fast, no container)
prlt work start TKT-042 --run-on-host --display background

# Docker + YOLO (full autonomy, safely sandboxed)
prlt work start TKT-042 --skip-permissions

Parallele Agenten

Gleichzeitig an mehreren Tickets arbeiten.

Interaktiv (Menschen):

$ prlt work spawn

? Spawn mode: Select specific tickets
? Select tickets:
  ◉ [P1] TKT-042 - Add user authentication
  ◉ [P1] TKT-043 - Add API rate limiting
  ◯ [P2] TKT-044 - Add email notifications
? Action: implement
? Environment: docker

Spawning 2 tickets...

JSON-Modus (KI-Agenten): (Mehrfachauswahl in Arbeit)

$ prlt work spawn --json --many
{
  "prompt": {
    "type": "checkbox",
    "message": "Select tickets to spawn:",
    "choices": [
      {"name": "[P1] TKT-042 - Add user authentication", "value": "TKT-042"},
      {"name": "[P1] TKT-043 - Add API rate limiting", "value": "TKT-043"}
    ]
  }
}

Flags (Skripte/CI):

prlt work spawn TKT-042 TKT-043 --action implement --mode docker

Jeder Agent arbeitet in seinem eigenen Branch. Keine Konflikte.

Skalierung: Die Hauptgrenze ist dein Rechner. 50+ gleichzeitige Agenten sind erreichbar – abhängig von CPU, RAM und ob du Docker oder Host-Modus verwendest.

Überwache laufende Agenten mit prlt execution:

flowchart LR
    subgraph You
        spawn[prlt work spawn]
    end

    subgraph Agents
        A1[Agent 1<br/>TKT-042 OAuth]
        A2[Agent 2<br/>TKT-043 Rate Limit]
        A3[Agent 3<br/>TKT-044 Notifications]
    end

    subgraph GitHub
        PR1[PR #101<br/>feat/TKT-042-oauth]
        PR2[PR #102<br/>feat/TKT-043-rate-limit]
        PR3[PR #103<br/>feat/TKT-044-notifications]
    end

    spawn --> A1
    spawn --> A2
    spawn --> A3

    A1 --> PR1
    A2 --> PR2
    A3 --> PR3

Von Agenten erstellte PRs bereit zur Überprüfung:

Befehlsreferenz

Führe prlt <command> --help für Flags und Optionen aus.

Anwendungsfälle

Parallele Feature-Entwicklung

# Create tickets for each feature
prlt ticket create --title "Add OAuth" --category feature
prlt ticket create --title "Add API rate limiting" --category feature
prlt ticket create --title "Add email notifications" --category feature

# Spawn all three in parallel (Docker for isolation)
prlt work spawn TKT-001 TKT-002 TKT-003 --mode docker

# Watch the board as they work
prlt board watch

Drei Agenten, drei Branches, drei PRs. Du überprüfst und mergst.

Bug Bash

# Spawn all bugs at once
prlt work spawn --all --column Backlog --category bug

# Or pick specific ones
prlt work spawn TKT-010 TKT-011 TKT-012

Grooming-Sitzung

Einen Agenten die Ticket-Anforderungen verfeinern lassen:

prlt work groom TKT-042

Agent fügt Akzeptanzkriterien, Unteraufgaben und Schätzungen hinzu.


Umgebungsvariablen

Variable

Zweck

GITHUB_TOKEN

GitHub-Operationen (PRs usw.)

Claude Code verwaltet seine eigene Authentifizierung über claude login.


Related MCP server: BMAD-MCP

Anforderungen

  • Node.js 20+ (22 LTS empfohlen)

  • Git

  • Claude Code (claude login zur Authentifizierung)

  • SQLite

  • Tmux (Sitzungspersistenz)

  • Docker (optional – für isolierte Ausführung)


Fehlerbehebung bei der Installation

bun install schlägt bei better-sqlite3 fehl

Symptom: bun install -g @proletariat/cli schlägt mit isexe- oder node-gyp-Fehlern während des Builds des nativen Moduls better-sqlite3 fehl.

Ursache: Buns node-gyp-Kompatibilität ist eingeschränkt. Die which-Abhängigkeit innerhalb von node-gyp verwendet isexe, das mit Buns Laufzeit-Shims inkompatibel ist.

Behebung: Verwende stattdessen npm oder Homebrew:

# Option 1: Homebrew (macOS, recommended)
brew install chrismcdermut/proletariat/prlt

# Option 2: npm (all platforms)
npm install -g @proletariat/cli

# Option 3: pnpm
pnpm install -g @proletariat/cli

Wenn du Bun verwenden musst, stelle sicher, dass Node.js 22 (LTS) ebenfalls installiert ist, und setze better-sqlite3 so, dass es seine vorgebauten Binärdateien verwendet:

npm rebuild better-sqlite3

npm EACCES: permission denied

Symptom: npm install -g @proletariat/cli schlägt mit EACCES: permission denied auf /opt/homebrew/lib/node_modules oder /usr/local/lib/node_modules fehl.

Behebung: Konfiguriere npm so, dass es ein benutzerbeschreibbares Verzeichnis verwendet:

mkdir -p ~/.npm-global
npm config set prefix '~/.npm-global'
export PATH="$HOME/.npm-global/bin:$PATH"
# Add the export line to your ~/.zshrc or ~/.bashrc
npm install -g @proletariat/cli

Oder verwende stattdessen Homebrew (macOS):

brew install chrismcdermut/proletariat/prlt

Native Modulfehler nach der Installation

Symptom: prlt läuft, stürzt aber mit better_sqlite3.node- oder ABI-Inkompatibilitätsfehlern ab.

Behebung:

# Rebuild for the current Node version
npm rebuild better-sqlite3

# Verify it works
node -e "require('better-sqlite3')"

# If still failing, reinstall
npm install -g @proletariat/cli --force

Siehe die vollständige Anleitung zur Fehlerbehebung für weitere Details.


Support


Lizenz

Apache 2.0


npm version Downloads License

Auf GitHub starren | Von NPM installieren | Probleme melden

Hergestellt mit ⚒️ vom Proletariat.

A
license - permissive license
-
quality - not tested
-
maintenance - not tested

Maintenance

Maintainers
1dResponse time
Release cycle
Releases (12mo)
Commit activity
Issues opened vs closed

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

  • -
    license
    B
    quality
    -
    maintenance
    Enables AI-driven orchestration of GitHub development workflows including automated issue analysis, code generation, code review, and PR creation through multiple specialized agents. Integrates with GitHub Actions to automate the complete development process from issue to pull request.
    7
  • A
    license
    B
    quality
    D
    maintenance
    Orchestrates complete agile development workflows from product requirements to QA testing through role-based stages (PO → Architect → SM → Dev → Review → QA). Manages workflow state, generates role-specific prompts, and saves artifacts while integrating with multiple AI engines for comprehensive project delivery.
    1
    35
    19
    MIT

View all related MCP servers

Related MCP Connectors

  • Create and manage AI agents that collaborate and solve problems through natural language interacti…

  • Build, validate, and deploy multi-agent AI solutions from any AI environment.

  • Git-backed platform for skills, tools, and context for AI agents

View all MCP Connectors

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/chrismcdermut/proletariat'

If you have feedback or need assistance with the MCP directory API, please join our Discord server