Viele KI-Projekte starten mit Begeisterung und enden im Prompt-Chaos. Workflows werden manuell verdrahtet, Sicherheit kommt zu spät, und der Sprung von der Demo in die Produktion wird zur Hürde.

Flock löst genau dieses Problem: Ein Open-Source-Framework, mit dem Entwickler produktionsreife KI-Agenten schneller bauen – strukturiert, sicher und wiederverwendbar. Es verbindet moderne Technologien mit klarer Architektur, damit aus Proof-of-Concepts echte Lösungen werden. Mehrere spezialisierte Agenten arbeiten gemeinsam und koordiniert an komplexen Aufgaben – robust, nachvollziehbar und skalierbar.

Mehr zu den Grundsätzen von Flock finden Sie in unserem Blogpost Flock – Our new open-source AI Agent Framework.

Mit Version 0.5 erneuern wir das Fundament von Flock: Subscriptions statt Graph‑Verdrahtung vereinfachen die Architektur und reduzieren Kopplung sowie Pflegeaufwand; Parallelität und Batching senken Modellkosten und Laufzeiten; End‑to‑End‑Tracing und ein Dashboard sorgen für lückenlose Nachvollziehbarkeit. Agenten skalieren ohne Umbau, indem sie Datentypen statt starrer Workflow‑Graphen abonnieren; klare Typ‑Schnittstellen statt Prompt‑Schleifen bringen Projekte schneller live, und Zero‑Trust Visibility liefert Sicherheit ab Tag eins.

Highlights auf einen Blick

Einige Überblick der wichtigsten Neuerungen in Flock 0.5:

• Redesign der gesamten Architektur und Code-Basis
• Zentrales Blackboard mit persistenter Speicherung
• Vollständige OpenTelemetry-Unterstützung, Jaeger-Frontend und eigenes Trace Viewer UI
• Deklarative Verträge mit @flock_type und Pydantic für stabile Ein-/Ausgabeschnittstellen
• Sichtbarkeitskontrolle mit fünf Visibility-Typen (Public, Private, Tenant, Labelled, After)
• Safety-Mechaniken: Circuit Breaker, Feedback Loop Prevention, Ausführungs-Limits
• BatchSpec & JoinSpec für Kostenreduktion und saubere Signal-Korrelation
• MCP-Integration (Model Context Protocol) für externe Tools/Server
• Vollständige OpenAPI REST-Dokumentation
• Tiefe Modularität: 7 Hooks im Agent-Lebenszyklus, Engine austauschbar
• Modellkompatibilität: Unterstützt aller relevanten Modelle über LiteLLM

Deklarative Agenten – Typed Contracts statt Prompt-Prosa

Natürliche Sprache ist großartig für Ideen – in Software aber schwer testbar und fragil. Prompt-Romane in Repos kann man nicht debuggen, kaum unit-testen und sie machen Probleme bei Modell-Updates. In Flock definieren Sie stattdessen klare, typisierte Verträge. Ihre Pydantic-Modelle sind die „Prompts“: validierbar, testbar, zukunftssicher über Modellgenerationen hinweg.

• Stabilität: Jeder Feld-Constraint gilt zur Laufzeit
• Testbarkeit: Verträge sind klar definiert und können getestet werden
• Zukunftssicherheit durch klare Typ-Spezifikation

Ein Beispiel:

from flock import flock_type
from pydantic import BaseModel, Field

@flock_type
class BugReport(BaseModel):
    title: str
    description: str

@flock_type
class BugDiagnosis(BaseModel):
    severity: str = Field(pattern="^(Critical|High|Medium|Low)$")
    confidence: float = Field(ge=0.0, le=1.0)

diagnoser = (
    flock.agent("diagnoser")
    .consumes(BugReport)
    .publishes(BugDiagnosis)
)

Blackboard-Orchestrierung – Pub/Sub mit Persistenz und Sichtbarkeit

Flock nutzt das Blackboard-Orchestrierungsmuster als Kernmechanik. Wie im echten Leben: Agenten „pinnen“ Nachrichten an ein zentrales Board. Andere Agenten sehen sie und entscheiden, ob sie handeln. Vollständig entkoppelt, ohne zentrale Orchestratoren oder Graphen.

• Weniger Verdrahtung: Agenten abonnieren Datentypen statt Knoten in einem DAG (Directed Acyclic Graph)
• Robustheit: Persistenz, Sichtbarkeit, Audit Trails
• Erweiterbarkeit: Neuen Agent hinzufügen, deklarativ abonnieren, fertig

Ein Beispiel:

book_idea_agent = (
    flock.agent("book_idea_agent")
    .description("Generates a compelling book idea.")
    .consumes(HumanInput)
    .consumes(Review, where=lambda r: r.score <= 8)
    .publishes(BookIdea)
)

reviewer_agent = (
    flock.agent("reviewer_agent")
    .description("A harsh critic. Reviews the book idea quality.")
    .consumes(BookIdea)
    .publishes(Review)
)

chapter_agent = (
    flock.agent("chapter_agent")
    .description("Generates a detailed outline for the book based on the latest draft.")
    .consumes(Review, where=lambda r: r.score >= 9)
    .publishes(BookOutline)
)

Weitere Highlights von Flock 0.5

JoinSpec + BatchSpec

Ereignisse zu korrelieren und effizient zu verarbeiten ist ohne deklarative Hilfen schnell eine eigene Queue‑ und Glue‑Code‑Baustelle. Mit JoinSpec definieren Sie, welche Signale zusammengehören und innerhalb welcher Zeitfenster, während BatchSpec Last bündelt, Kosten senkt und Durchsatz steigert. Das bringt korrekte Korrelation, bessere Performance und weniger Infrastruktur‑Sonderlogik—Komplexität verschwindet in klaren Spezifikationen statt in selbstgebauten Pipelines.

Ein Beispiel:

from datetime import timedelta
from flock.specs import JoinSpec, BatchSpec

aggregator = (
    flock.agent("aggregator")
    .consumes(SensorReading, SensorReading,
              join=JoinSpec(by=lambda r: r.device_id, within=timedelta(seconds=30)),
              batch=BatchSpec(size=20, timeout=timedelta(seconds=10)))
    .publishes(AggregatedWindow)
)

Out-of-the-Box Visibility & Compliance

In mehrmandantigen und regulierten Umgebungen ist Least‑Privilege kein Nice‑to‑Have, sondern Pflicht—Daten dürfen nur dort sichtbar werden, wo sie hingehören. Flock bringt feingranulare Sichtbarkeitstypen, mit denen Sie Zugriffe pro Artefakt und Agent deklarativ steuern. Das verhindert Cross‑Tenant‑Leaks, erleichtert Audits und setzt Security‑by‑Design praktisch um—saubere Mandantentrennung und Compliance von Anfang an.

Ein Beispiel:

from flock.visibility import PrivateVisibility, TenantVisibility

patient_scan = (
    flock.agent("radiology")
    .consumes(Scan)
    .publishes(XRayAnalysis, visibility=PrivateVisibility(agents={"diagnostician"}))
)

customer_agent = (
    flock.agent("profile_builder")
    .consumes(ProfileEvent)
    .publishes(UserProfile, visibility=TenantVisibility(tenant_id="tenant_42"))
)

Distributed Tracing & Analyse

Nichtdeterministische Agentensysteme brauchen erstklassige Observability, sonst bleiben Performance‑Tuning und Fehlersuche ein Blindflug. Mit automatischem Tracing und einer DuckDB‑gestützten Analyse greifen Sie per SQL auf Spans zu, finden Hotspots und verstehen Kosten‑Treiber in Minuten. So identifizieren Sie Bottlenecks, belegen Budgets und verbessern systematisch—Performance und Fehlerursachen sind in Sekunden sichtbar.

Ein Beispiel:

export FLOCK_AUTO_TRACE=true
export FLOCK_TRACE_FILE=true

import duckdb
db = duckdb.connect('.flock/traces.duckdb', read_only=True)
hot = db.execute(
    "SELECT name, AVG(duration_ms) "
    "FROM spans GROUP BY name ORDER BY 2 DESC LIMIT 5"
).fetchall()

Weitere neue Features & Getting Started

Sie wollen alle Features im Detail sehen und wissen, wie die Umsetzung aussieht? Werfen Sie einen Blick in das GitHub‑Repository und in die Dokumentation – dort finden Sie vollständige Beschreibungen, Beispiele und Schritt‑für‑Schritt‑Anleitungen zur Implementierung:

• GitHub-Repository: whiteducksoftware/flock
• Dokumentation: whiteducksoftware.github.io/flock

Wir haben dieses Projekt aus der Leidenschaft heraus gestartet, die Entwicklung von KI-Agenten für alle zugänglich und effektiv zu machen. Als Open-Source-Initiative verkörpert Flock unseren Glauben an Zusammenarbeit und Community-getriebenen Fortschritt. Wir laden jeden ein, beizutragen, Feedback zu geben und Ihre Ideen zu teilen.