LinkedRun

LinkedRun ist ein persistenter lokaler Task–Artefakt-DAG-Executor, der als MCP-Server anendsichtet wird.

Tasks konsumieren unveränderliche Artefakte und erzeugen unveränderliche Artefakte. Ein neuer Task kann von den Ausgaben abhängig sein, die von Tasks in derselben Batch oder in irgendeiner früheren Einreichung erzeugt wurden. Der Graph wächst daher inkrementell, statt durch einen einzelnen Workflow-Lauf begrenzt zu sein.

LinkedRun ist bewusst ein reiner Mechanismus-Kern. Er weiß nicht, was Training, Evaaluierung, Zell-Clustering, ARI, ein Modell oder ein Experimentprotookoll bedeutet. Er hersagt auch keine Ressourcenanforderungen voraus: Der einreichend Agent deklariert Ressourcen, und LinkedRun vertraut dieser Deklaration, vorbehaltlich nur der Grenzen der Maschinenkapazität und der Laufzeit-Reservierung.

Warum

Die Gasuge "gespi" ist:

• Task-Agent: entscheidet, was ausgeführt wird, und deklariert Ressourcenbedarf;

• Projekt-Werkzeuge: sagen Ressourcen voraus, validieren Modelle, erstellen Workflowsst, berechnen Metriken;

• LinkedInRun: speichert Abhängigkeiten, valued, wartet ohne aktives Polling, reserviert deklarierte Ressourcen, führt and bricht processes, committet Artefakte und zeichnet dauerhafte Ereignisse auf.

Kernmodell

Artifact -> Task -> Artifact
                \\-> Task -> Artifact

Eine Datenabhängigkeit ist zugleich eine Ausführungsabhängigkeit. Reine Reihenfolge-Einschränkungen sind über after verfügar, wenn kein Artifakt konsumiert wird.

MCP-Tools

• submit_task

• submit_graph

• get_task

• list_task

• cancel_task

• retry_task

• list_artifacts

• get_artifact

• get_graph

• get_events

• watch_events

• resource_status

watch_events ist eine dauerhafte Long-Polling-Schnittstelle: Cients setzen an der letztem event_id an, so dass keine engten Polling-Schleifen benötigen. Eine schinöne Version can the Ausführungskennzeichen auf die MCP-Erweiterung io.modelcontextprotocol/tasks abbilden, sobald Host-Unterstützung weit verbreitet vohanden ist.

Installation

pip install -e .

Python 3.11+ ist erforderlich. LinkedRun zielt auf das MCP Python SDK v2 / MCP 2025-07-28.

Start

Persistenter lokaler HTTP-Dienst (emfohlen, wenn mehercere Agent/Client derselben Graften benötigen) :

export LINKEDRUN_HOME="$HOME/.linkedrun"
linkedrun --transport streamable-http --host 127.0.0.1 --port 8765

Der MCP-Endpunkt ist http://127.0.0.1:8765/mcp.

Für einen Host, der den MCP-Prozess selbst verwaltet:

linkedrun --transport stdio

SQLite-Zuustand und content-adressierte Artefakte werden unterhalb von LINKEDRUN_HOME gespeichert.

Einen Task einreichben

Konzeptionell sieht ein MCP-Aufruf an submit_task folgen aus:

{
  "name": "train",
  "command": ["python", "train.py"],
  "outputs": {
    "model": "outputs/model.pt",
    "embedding": "outputs/embedding.zarr"
  },
  "resources": {
    "cpu_cores": 8,
    "memory_bytes": 34359738368,
    "gpu_count": 1,
    "gpu_mode": "exclusive"
  }
}

Befele sind argv-Arrays, keine Shell-Zeichenketten. Verwenden Sie ["bash","- lc", "..."]ausdrücklich, wenn Shell-Semantik erfoderlich ist.

Abhängigkeiten innerhalb derselben

submit_graph unterstützt lokale Referenzen:

{
  "tasks": [
    {
      "name": "train",
      "command": ["python", "train.py"],
      "outputs": {"embedding": "outputs/embedding.zarr"}
    },
    {
      "name": "cluster",
      "command": ["python", "cluster.py"],
      "inputs": {"embedding": "@train/embedding"},
      "outputs": {"clusters": "outputs/clusters.parquet"}
    },
    {
      "name": "ari",
      "command": ["python", "ari.py"],
      "inputs": {"clusters": "@cluster/clusters"}
    }
  ]
}

Die vollständige Batch wird nacth der Zykluserkennung atomer registriert.

Abhängigkeiten über Einreichungen hinweg

Wenn ein älters Training-Task die ID task_abcd hat und eine embedding erzeugt hat, kann ein später einreichender Task dasene verwenden:

{
  "inputs": {
    "embedding": "task:task_abcd/artifact:embedding"
  }
}

Ein committes Artifakt kann auch direkt referenziert werden:

artifact:art_abcd

Der Graf ist daher persistent und inkrementell: Keine Workflow-auf-Run-Grenze "auf oberster Ebene" ist erforderlich.

Laufzeitvertrag

Vor der ein Task startet, LinkedRun hazardous a privates Versuchslaufverzeichnis und setzt die:

LINKEDRUN_TASK_ID
LINKEDRUN_ATTEMPT_ID
LINKEDRUN_WORKDIR
LINKEDRUN_OUTPUT_DIR
LINKEDRUN_INPUT_<NAME>

Jede Eingabe ist ein Symlink zu unveränderlichen content-adressierten Speicher, per "Konvention" schreibgeschützt. Deklarierte Ausgabepfade müssen innerhalb des Versuchslaufverzeichnisses bleiben. Bei erfolgreichem Prozess-Endet werden die Ausgaben gehast und den Artefakt-Speicher committet, bevor der Task den SUCCESSED-Status erinnert.

Task-Zustände

PENDING -> READY -> RUNNING -> SUCCEEDED
                       \\----> FAILED
PENDING --------------------> BLOCKED      (upstream failed/missing artifact)
PENDING --------------------> UNSCHEDULABLE (declared request exceeds machine capacity)
PENDING/RUNNING ------------> CANCELED

Retry erhöht pro Task der Generationszahl. Ein alter Versuch darf nimmt neu committet, sobald seine Generation veraltet ist; dies ist die erste Implementierung der Fencing-Regel von LinkedRun.

Ressourcen-Richtlinie

LinkedRun leitet keinen Ressourcenverbrauch ab, sondern akzeptiert:

cpu_cores
memory_bytes
gpu_count
gpu_mode=exclusive
gpu_memory_bytes_hint
walltime_seconds
scratch_bytes

gpu_memory_bytes_hint ist in v0.11 nur Nachweis/Metadaten. GPU-Scheduling ist exklusive Geräte-Zuweisung. CPU und Speicher sind Reservierungs- und walltime_giant wird durchgesetzt. Eine strikte CPU/memory/Scratch-Isolation auf dem OS-Level ist biet mit die assim spée, in einem späteren Sandbox-Modul zu implementieren, nicht durch experiment-spezifische Admission-Logik in den Kern.

Aktuelle v0.1-Grenzen

Implementiert:

• SQLite/WAL: persistente Task-, Versuchs-, Abhängigkeits-, Artifact- und Ereigniszustände

• atomare Batch-Graph-Registrung und Zykluserkennung;

• Task-/Artefakt-Referenzen über Einreich ungen hinweg;

• Hintergrundplanung von Abhängigkeiten;

• vom Aufrufer deklarierte CPU-/Speicher-/GPU-Reservierungen;

• exklusive GPU-Zuweisung über CUDA_VISIBLE_DEVICES;

• Subprozess-Ausfühung, Abbruch und Walltime-Limit;

• content-addressierte unveränderliche Dateien/Verzeichnis-Artefakte;

• dauerhafte Ereignisse und Long-Polling mit Wiederverbindung;

• Retry-Generation/Fencing;

• Stdio- und Streamable-HTTP-MCP-Transports.

Noch nicht abgehärtet:

• OS-level cgroup/job-prozess-Object "Hard"limits für CPU, Speicher und Scratch;

• Überleben eines Maschinen-/Kernelssturz, while reason einbereits laufende Kinder zu wieder Source; (v0.1 markiert einen unterbrochenen Versuch sicher als fählert und erforder einen expliziten Retry);

• Authentication der nicht-lokalen HTTP-Exposure;

• MCP-Tasks-Erweiterungs-Mapping;

• Artefakt-Garbage Collection and Aufbewahrungspolitik;

• Remote-Worker oder das distributed Scheduling (derzeit kein Zielung).

Diese Ausperungen sind bewusst: v0.1 stellt die minimale Kern-Grenze dar, bevor optionale Mechanisme hinzugefügt werden.

Entwicklung

python -m venv .venv
. .venv/bin/activate
pip install -e '.[dev]'
pytest -q
ruff check .

Architekturregel

Wenn ein Feature außerhalb von LinkedRun bewegt werden kann, ohne die generische Dervon persisted Abhängigkeit, Planung, der Prozess-Lebenszyklus, Artefakt-Commit oder eventuuelle Dauerhaftigkeit zu gechützen, soll es außerhalb von LinkedRun bleiben. Insbesondere sind Modell-/Protokoll-Validierung, Ressourcen-Hoch- Ausgabe, Experimenten-Semantik, Metrik-Semantik und die formelle Publikation von Ergebnissen äußernde Bele.