Paperclip: Open-Source-Framework für Ein-Personen-Unternehmen

Paperclip ist ein Open-Source-Framework für Ein-Personen-Unternehmen, das KI-Agenten wie Mitarbeiter orchestriert: Organigramme, Budgets, Heartbeat-Planung, Governance-Genehmigungen und ein vollständiges Audit-Protokoll. Ein einziger Befehl richtet es lokal ein. Ihre Agenten erledigen die Arbeit; Sie leiten die Vorstandssitzung.

Probiere Apidog noch heute aus

Ein Ein-Personen-Unternehmen im Jahr 2026 zu führen, bedeutet nicht länger, alles selbst zu erledigen – es bedeutet, ein Team von KI-Agenten zu leiten, die die Arbeit erledigen, während Sie sich auf die Strategie konzentrieren. Paperclip ist das Open-Source-Framework für Ein-Personen-Unternehmen, das entwickelt wurde, um dies Wirklichkeit werden zu lassen. Es bietet Einzelgründern ein Organigramm, ein Budgetsystem, eine Governance-Ebene und einen Aufgaben-Tracker für ihre KI-Agenten, alles in einem selbst gehosteten Dashboard. Wenn Sie auch Apidog verwenden, um die APIs, mit denen Ihre Agenten interagieren, zu entwerfen, zu simulieren und zu testen, vervollständigt Paperclip den Stack: Apidog ist für den API-Vertrag verantwortlich, Paperclip für die Agenten, die ihn aufrufen. Dieser Leitfaden erklärt, wie Paperclip funktioniert und wie Sie es direkt in Ihren Ein-Personen-Betrieb integrieren.

💡Holen Sie sich Apidog (kostenlos) vor Ihrem ersten Paperclip-Heartbeat. Betten Sie Mock-URLs in Aufgabenbeschreibungen ein, damit Agenten perfekte Verträge erstellen – keine Kosten, keine Überraschungen. Wechseln Sie später zu Live-APIs, wobei Apidog-Tests jede Abweichung erkennen, bevor das Budget verbraucht ist.

Was ist Paperclip und warum ist das Framework für Ein-Personen-Unternehmen für Apidog-Benutzer wichtig?

Der Slogan von Paperclip bringt es auf den Punkt: "Wenn OpenClaw ein Mitarbeiter ist, ist Paperclip das Unternehmen."

Paperclip ist ein Node.js-Server mit React-UI, der Ihre KI-Agenten in eine strukturierte Organisation überführt – mit Titeln, Berichtswegen, Budgets und strategischen Zielen. Es ist keine Chatbot-Lösung, kein Prompt-Manager, sondern die Steuerungsebene für ein autonomes Unternehmen.

Warum ist das relevant?

Einzelgründer, die 2026 KI-Agenten nutzen, managen oft Chaos: Kein Überblick, welche Agenten was bearbeiten, keine Budgetkontrolle, keine Statusübersicht. Paperclip löst das – mit klaren Strukturen:

• Organigramm: Rollen, Titel, Management-Hierarchie für Agenten
• Aufgaben-Tracking: Status, Priorität, Verantwortliche für jede Aufgabe
• Zielausrichtung: Aufgaben führen immer auf das Unternehmensziel zurück
• Heartbeats: Agenten arbeiten nach Zeitplan, holen Aufgaben und melden Status zurück
• Budgets: Monatliche Token-Limits für Agenten, automatische Sperre bei Überschreitung
• Governance: Sie entscheiden über Einstellungen und strategische Schritte

Nutzen Sie Apidog für Ihre API-Mocks und -Spezifikationen, orchestriert Paperclip die Arbeitsverteilung, Statuskontrolle und Budgetierung für die Agenten.

Warum Einzelgründer dieses Framework dem "Apidog-alleine"-Ansatz vorziehen

Apidog deckt das API-Design und das Testen ab – aber nicht Aufgabenverteilung, Fortschritts-Tracking, Kostenkontrolle oder Governance. Paperclip ergänzt diese Lücken: Sie erhalten ein vollständiges Betriebssystem für Ihr Ein-Personen-Unternehmen, in dem Apidog die API-Vorgaben liefert und Paperclip die Ausführung steuert.

Kernfunktionen des Paperclip-Frameworks und die Rolle von Apidog

Heartbeats: Die Apidog-kompatible Agenten-Aktivierungsschleife

Der Heartbeat ist das zentrale Steuerungselement. Jeder Agent führt pro Heartbeat folgende Schritte durch:

1. GET /api/agents/me – Agentenidentität prüfen
2. GET /api/companies/:id/issues?status=todo,in_progress – Aufgaben-Posteingang abrufen
3. GET /api/issues/:id – Kontext und Zielhierarchie laden
4. Aufgabe ausführen (z.B. Code schreiben, APIs aufrufen)
5. PATCH /api/issues/:id – Status- und Ergebnisbericht abgeben

Praxisbeispiel:

Wenn eine Aufgabe einen externen API-Call benötigt, trifft der Agent im Entwicklungsmodus auf einen Apidog-Mock-Server. In Produktion wird nahtlos auf den Live-Endpunkt umgeschaltet, ohne Codeänderung. Apidog erkennt Vertragsabweichungen sofort.

Organigramm und Zielhierarchie: Apidog als API-Schicht

Die Hierarchie verläuft: Unternehmen → Team → Agent → Aufgabe. Agenten erhalten Aufgaben immer inklusive Zielkette (z.B. "Blogartikel zur Steigerung von SEO-Traffic für 1 Mio. $ MRR"). Dadurch arbeiten Agenten immer im Kontext des Gesamtziels.

API-Verträge:

Apidog dient als Spezifikationsebene. Definieren Sie interne Services in Apidog, veröffentlichen Sie Mocks und referenzieren Sie deren Endpunkte direkt in den Aufgabenbeschreibungen. Nach API-Änderungen Mock aktualisieren – die Agenten nutzen automatisch die neue Version.

Budgetkontrolle: Ausgaben in Ihrem Apidog-Workflow begrenzen

Jeder Agent besitzt ein Feld budgetMonthlyCents. Wird das Limit überschritten, nimmt der Agent keine Aufgaben mehr an – ohne Ausnahme. So können Sie Agenten z.B. ein 20 $/Monat-Budget zuweisen und sind vor Kostenexplosionen geschützt.

Kombiniert mit Apidog:

Führen Sie komplette Agentensprints gegen Mocks (keine Token-Kosten) durch, bevor Sie in die Produktion gehen. Prototyping bleibt kostenfrei, produktiver Einsatz ist budgetiert.

Paperclip als Framework für Ein-Personen-Unternehmen mit Apidog einrichten {#setup}

Lokaler Start ohne Konfiguration: Apidog sofort einbinden

Paperclip starten Sie mit nur einem Befehl:

npx paperclipai onboard --yes

Das bootet eine eingebettete PostgreSQL-Datenbank, generiert den Master-Key, führt Migrationen durch und startet den Server unter http://localhost:3100. Keine externen Abhängigkeiten, kein Docker nötig.

Schnellstart:

1. Oberfläche öffnen, Unternehmen anlegen, Ziel definieren:
   

   Das #1 KI-gestützte API-Überwachungstool auf 1 Mio. US-Dollar MRR aufbauen.
   

2. Ersten Agenten anlegen (z.B. "Backend Engineer" mit Claude-Adapter):
   

   {
     "adapterType": "claude_local",
     "adapterConfig": {
       "model": "claude-opus-4-6",
       "maxTokens": 4096
     },
     "budgetMonthlyCents": 2000
   }
   

3. Aufgaben so formulieren, dass sie auf einen Apidog-Mock-Server zeigen – z.B. durch Verweis in der Aufgabenbeschreibung auf die Apidog-Sammlungs-URL.

Apidog Mocks mit Agentenaufgaben verknüpfen

In Paperclip sind Aufgabenbeschreibungen Markdown mit Kontext. Betten Sie die Apidog Mock-Basis-URL direkt ein:

## Aufgabe: Paginierung zum /users-Endpunkt hinzufügen

**Apidog Mock-Basis:** http://localhost:4523/m1/123456/users
**Abnahmekriterien:**
- Endpunkt akzeptiert `page`- und `limit`-Abfrageparameter
- Gibt `{ data: [], total: 0, page: 1 }`-Umschlag zurück
- Unit-Test-Abdeckung für Grenzfälle (page=0, limit>100)

Der Agent liest die Kriterien, ruft den Mock ab, entwickelt die Lösung und gibt Rückmeldung.

Agenten, Aufgaben und Heartbeats im Paperclip-Framework mit Apidog ausführen

Aufgaben in der Paperclip-Apidog-Pipeline verwalten

Mit der Paperclip-CLI steuern Sie den Lebenszyklus von Aufgaben direkt im Terminal:

# Neue Aufgabe für einen Apidog-Endpunkt anlegen
pnpm paperclipai issue create \
  --company-id <id> \
  --title "Implementiere POST /webhooks-Endpunkt gemäß Apidog-Spezifikation" \
  --description "Siehe Apidog-Sammlung: http://localhost:4523/..."

# Aufgabenstatus prüfen
pnpm paperclipai issue list --company-id <id> --status in_progress

# Aufgabe freigeben, falls Agent blockiert
pnpm paperclipai issue release <issue-id>

Alle Statusänderungen werden im Audit-Log erfasst.

Governance und Genehmigungen im Apidog-integrierten Framework

Paperclip bietet ein Governance-Modell: Sie genehmigen Einstellungen und strategische Schritte explizit.

# Ausstehende Genehmigungen prüfen
pnpm paperclipai approval list --company-id <id>

# Neue Agenten-Einstellung genehmigen
pnpm paperclipai approval approve <approval-id> \
  --decision-note "Genehmigt. Verwende Apidog Mock für den ersten Sprint."

So behalten Sie die Kontrolle – Agenten schlagen vor, Sie entscheiden.

Testen, Governance und Kostenkontrolle in Ihrem Paperclip + Apidog Stack

Paperclip-Apidog-Unit-Tests ausführen

Paperclip liefert Unit-Tests (Vitest) und End-to-End-Tests (Playwright) mit:

# Unit-Tests ausführen
pnpm test:run

# End-to-End-Tests
pnpm test:e2e

# Server-Gesundheitscheck inkl. Apidog Mock
curl http://localhost:3100/api/health

Die Tests prüfen Kernlogik, Zustandsübergänge, Budgetgrenzen und Agentenauthentifizierung. Bei neuen Adaptern läuft die Suite als Integrationscheck.

Wichtig für Einzelgründer:

Ohne Peer-Review sind Unit-Tests und Apidog-Vertragstests Ihr Sicherheitsnetz.

Der dreischichtige Qualitäts-Stack: Paperclip + Apidog + Unit-Tests

Ein erprobtes Muster für Qualität:

1. Apidog – definiert API-Verträge, automatisierte Vertragstests bei jedem Push
2. Paperclip – Aufgaben mit Akzeptanzkriterien, die auf Apidog-Spezifikationen verweisen
3. Unit-Tests (Vitest) – prüfen die Implementierung gegen beide Ebenen

Damit erreichen Sie als Einzelgründer Qualitätssicherung wie mit einem fünfköpfigen Team – ohne Meetings.

Fazit

Paperclip ist das Open-Source-Framework, das Einzelgründer zu Unternehmen macht. Es bringt Organigramme, Budgetkontrolle, Governance, Zielausrichtung, Heartbeat-Planung und Audit-Log in Ihre KI-Agentenverwaltung – alles selbst gehostet und Open Source.

Nutzen Sie bereits Apidog für API-Design und Tests, ergänzt Paperclip Ihren Stack optimal:

Apidog regelt, was die API tut. Paperclip steuert, wer sie wann, warum und zu welchen Kosten aufruft. Zusammen ist Ihr Framework produktionsreif: Apidog-Mocks treiben die Agentenentwicklung an, Vertragstests validieren die Ergebnisse, Paperclip-Governance gibt Ihnen maximale Kontrolle.

Sofort umsetzen:

• Lokal starten: npx paperclipai onboard --yes
• UI öffnen: http://localhost:3100, Unternehmen und Ziel anlegen
• Agent mit Budget (z.B. 20 $/Monat) hinzufügen und auf Apidog-Mock-Server ausrichten
• pnpm test:run ausführen, um die Unit-Test-Suite zu prüfen
• Erste Aufgabe genehmigen, Agentenarbeit beobachten, Audit-Log einsehen

Das Ein-Personen-Unternehmen ist keine Metapher mehr. Mit Paperclip und Apidog ist es eine Architektur.

FAQ

Was ist Paperclip?

Paperclip ist ein Open-Source-Framework für Ein-Personen-Unternehmen – ein Node.js-Server und eine React-Benutzeroberfläche, die KI-Agenten mit Organigrammen, Budgets, Heartbeat-Planung und Governance orchestriert. Es ist die Steuerungsebene für den Betrieb eines Softwareunternehmens mit KI-Agenten anstelle menschlicher Mitarbeiter.

Wie lässt sich Paperclip in Apidog integrieren?

Apidog definiert die API-Verträge, mit denen Ihre Agenten arbeiten. Sie betten Apidog Mock-URLs in Paperclip-Aufgabenbeschreibungen ein, Agenten rufen diese Mocks während der Entwicklung auf, und Apidogs Vertragstests validieren die endgültige Implementierung. Paperclip übernimmt die Orchestrierung; Apidog die API-Spezifikation.

Ist Paperclip für ein echtes Ein-Personen-Unternehmen geeignet?

Ja. Das lokale Setup ohne Konfiguration (npx paperclipai onboard --yes) benötigt keine Infrastruktur. Budgetlimits verhindern ausufernde Kosten. Das Heartbeat-System automatisiert wiederkehrende Aufgaben. Mit Tailscale verwalten Sie Ihre Agenten sogar vom Smartphone. Skalierung von lokal bis Cloud – immer gleiche Konfiguration.

Wie führe ich die Unit-Tests aus?

Mit pnpm test:run (Vitest-Unit-Tests) oder pnpm test:e2e (Playwright-End-to-End-Tests). Ein Gesundheitscheck unter http://localhost:3100/api/health bestätigt, dass der Server korrekt läuft.

Welche KI-Agenten unterstützt Paperclip?

Paperclip unterstützt Claude (lokal und via OpenClaw), Codex, Cursor, Gemini, OpenCode sowie jeden Agenten, der HTTP spricht oder als lokaler Prozess läuft. Das Adapter-System ist offen: Wenn Ihr Agent einen Heartbeat empfangen kann, kann er integriert werden.

Ist Paperclip Open Source?

Ja. Paperclip ist MIT-lizenziert und wird aktiv auf github.com/paperclipai/paperclip gepflegt. Plugin-SDK, Adapter und Skills werden als NPM-Pakete unter @paperclipai/* veröffentlicht.