---
title: Einführung
description: >-
  Runic ist ein sitzungsübergreifender Cache und Token-Ledger für bereits
  gelöste Entscheidungen eines Agenten.
---
Agenten entscheiden Dinge erneut, die sie bereits entschieden haben. Derselbe PR wird zweimal zusammengefasst, dieselbe Datei zweimal überprüft, derselbe Changelog-Eintrag zweimal erstellt — und jedes Mal zahlt der Agent den vollen Preis, um eine Antwort neu zu erzeugen, die er bereits produziert hat. Runic merkt sich stattdessen die Antwort.

:::tip
**Einmal fragen. Einmal zahlen.**
:::

## Was Runic ist

Runic steht neben allem, was ein Agent bereits zum Handeln nutzt — einschließlich MCP-Tool-Aufrufen — als optionale Prüfung: *„Habe ich diese exakte Entscheidung schon einmal gelöst?“*

- **Ein Cache**, der auf einer normalisierten Signatur mit exakter Übereinstimmung einer bereits vom Agenten getroffenen Entscheidung basiert — `{ intent, params }`, niemals roher Aufgabentext, niemals ein Reasoning-Trace.
- **Ein Ledger**, das ausgegebene Tokens (vom Agenten gemeldet) gegenüber bei Wiederverwendung eingesparten Tokens protokolliert. Reine Buchhaltung, keine Durchsetzung.
- **Sitzungsbezogener Geltungsbereich.** Sitzungs- und agentenübergreifendes Teilen ist eine spätere Phase, sobald sich gezeigt hat, dass Wiederverwendung pro Sitzung relevant ist.

## Was Runic bewusst nicht ist

- **Keine Ausführungsebene.** Runic ruft niemals eine Fähigkeit auf, stellt etwas bereit oder führt Code aus — der Agent erledigt das selbst, auf die Weise, die er bereits nutzt.
- **Kein Berechtigungs- oder Sandboxing-System.** Es gibt nichts zu prüfen, wenn nichts ausgeführt wird.
- **Kein semantischer Cache.** Die Übereinstimmung erfolgt exakt auf der gelösten Entscheidung, nicht unscharf auf der Formulierung, die zu ihr geführt hat. Siehe [Geltungsbereich](/scope), warum das eine Einschränkung und keine Abkürzung ist.

## Installation

```package-install
npm i @runic-labs/sdk
```

## Der Ablauf

```txt
agent resolves a task into a structured decision
        │
        ▼
askRunic({ intent, params })
        │
        ├─ hit  → return cached artifact, log tokens saved
        └─ miss → agent generates its own way (as it does today)
                        │
                        ▼
                storeResult({ intent, params }, artifact, tokensSpent)
```

Zwei Funktionen bilden den gesamten agentenseitigen Vertrag. Alles andere in diesem Repo unterstützt diese beiden Aufrufe.

<CodeGroup>

```ts Without Runic
// Every call regenerates the answer, even for a decision you've
// already resolved once today.
async function summarizePr(repo: string, pr: number) {
  const result = await callYourLLM(promptFor(repo, pr));
  return result; // paid full price, every single time
}
```

```ts With Runic
import { askRunic, storeResult } from "@runic-labs/sdk";

async function summarizePr(repo: string, pr: number) {
  const decision = { intent: "summarize_pr", params: { repo, pr } };

  const cached = await askRunic(decision);
  if (cached) return cached.artifact; // no LLM call, no tokens spent

  const result = await callYourLLM(promptFor(repo, pr));
  await storeResult(decision, result, result.tokensUsed);
  return result;
}
```

</CodeGroup>

## Reale Zahlen, keine Schätzungen

Runic misst die Tokenkosten niemals selbst — der Agent meldet sie anhand dessen, was sein eigener Anbieter tatsächlich zurückgegeben hat. Ein realer Durchlauf gegen OpenRouter, der 48 Entscheidungen löste, von denen nur 8 tatsächlich einzigartig waren:

```json
{
  "decisions": 48,
  "uniqueDecisions": 8,
  "apiCalls": 8,
  "cacheHits": 40,
  "tokensSpent": 2582,
  "tokensSaved": 12910,
  "tokensWithoutRunic": 15492,
  "savingsPercent": 83
}
```

Siehe [Benchmarks](/benchmarks), um dies selbst zu reproduzieren, sowie einen synthetischen Durchlauf, der zeigt, dass derselbe Mechanismus bei 10.000 Entscheidungen funktioniert.

## Pakete

| Paket | Funktion |
| --- | --- |
| [`@runic-labs/sdk`](/sdk) | `askRunic` / `storeResult` — der gesamte agentenseitige Vertrag |
| [`@runic-labs/cache`](/cache) | Signatur → Artefaktspeicher (im Arbeitsspeicher + dateibasiert) |
| [`@runic-labs/ledger`](/ledger) | Abrechnung ausgegebener gegenüber eingesparter Tokens |
| [`@runic-labs/cli`](/cli) | `runic cache status`, `runic ledger status` |

## Nächste Schritte

- [Schnellstart](/quickstart) — binde Runic in wenigen Minuten in deinen Agenten ein
- [Funktionsweise](/how-it-works) — der Signaturalgorithmus und warum die Übereinstimmung exakt ist
- [Geltungsbereich](/scope) — was aus dem früheren Plan für eine Ausführungsebene gestrichen wurde und warum

## Mitwirken

Runic ist Open Source und freut sich über Beiträge. Siehe `CONTRIBUTING.md` im Repo für Richtlinien.

## Lizenz

MIT