---
title: Introduction
description: >-
  Runic est un cache inter-session et un registre de jetons pour les décisions
  déjà résolues d'un agent.
---
Les agents redécident de choses qu'ils ont déjà décidées. La même PR est résumée deux fois, le même fichier est révisé deux fois, la même entrée de journal des modifications est générée deux fois — et à chaque fois, l'agent paie le prix fort pour régénérer une réponse qu'il a déjà produite. Runic se souvient de la réponse à la place.

:::tip
**Demandez une fois. Payez une fois.**
:::

## Ce qu'est Runic

Runic se place à côté de tout ce qu'un agent utilise déjà pour agir — y compris les appels d'outils MCP — comme vérification facultative : *« ai-je déjà résolu cette décision exacte auparavant ? »*

- **Un cache**, indexé sur une signature normalisée à correspondance exacte d'une décision que l'agent a déjà prise — `{ intent, params }`, jamais le texte brut de la tâche, jamais une trace de raisonnement.
- **Un registre**, qui consigne les jetons dépensés (signalés par l'agent) par rapport aux jetons économisés lors de la réutilisation. Simple suivi comptable, sans application de règles.
- **Portée par session.** Le partage inter-session/inter-agent est une phase ultérieure, une fois qu'il sera prouvé que la réutilisation par session importe.

## Ce que Runic n'est délibérément pas

- **Pas une couche d'exécution.** Runic n'appelle jamais une capacité, ne déploie rien et n'exécute pas de code — l'agent le fait lui-même, comme il le fait déjà.
- **Pas un système d'autorisations ou de sandboxing.** Il n'y a rien à vérifier si rien ne s'exécute.
- **Pas un cache sémantique.** La correspondance est exacte sur la décision résolue, et non approximative sur la formulation qui y a conduit. Consultez [Portée](/scope) pour comprendre pourquoi c'est une contrainte, pas un raccourci.

## Installation

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

## La boucle

```txt
agent résout une tâche en une décision structurée
        │
        ▼
askRunic({ intent, params })
        │
        ├─ succès  → renvoyer l'artefact en cache, consigner les jetons économisés
        └─ échec   → l'agent génère à sa manière (comme il le fait aujourd'hui)
                        │
                        ▼
                storeResult({ intent, params }, artifact, tokensSpent)
```

Deux fonctions constituent l'intégralité du contrat destiné à l'agent. Tout le reste de ce dépôt prend en charge ces deux appels.

<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>

## Des chiffres réels, pas des estimations

Runic ne mesure jamais lui-même le coût des jetons — l'agent le signale, en utilisant ce que son propre fournisseur a réellement renvoyé. Une exécution réelle avec OpenRouter, résolvant 48 décisions dont seulement 8 étaient réellement uniques :

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

Consultez [Benchmarks](/benchmarks) pour savoir comment reproduire cela vous-même, ainsi qu'une analyse synthétique montrant que le même mécanisme tient à 10 000 décisions.

## Paquets

| Paquet | Fait |
| --- | --- |
| [`@runic-labs/sdk`](/sdk) | `askRunic` / `storeResult` — l'intégralité du contrat destiné à l'agent |
| [`@runic-labs/cache`](/cache) | magasin signature → artefact (en mémoire + sauvegardé dans des fichiers) |
| [`@runic-labs/ledger`](/ledger) | comptabilisation des dépenses par rapport aux économies |
| [`@runic-labs/cli`](/cli) | `runic cache status`, `runic ledger status` |

## Prochaines étapes

- [Démarrage rapide](/quickstart) — intégrez Runic à votre agent en quelques minutes
- [Comment cela fonctionne](/how-it-works) — l'algorithme de signature et pourquoi la correspondance est exacte
- [Portée](/scope) — ce qui a été supprimé du plan antérieur de couche d'exécution, et pourquoi

## Contribuer

Runic est open source et accueille les contributions. Consultez `CONTRIBUTING.md` dans le dépôt pour connaître les consignes.

## Licence

MIT