परिचय

Runic किसी एजेंट के पहले से हल किए गए निर्णयों के लिए एक क्रॉस-सेशन कैश और टोकन लेजर है।

एजेंट उन चीज़ों का फिर से निर्णय लेते हैं जिनका वे पहले ही निर्णय ले चुके हैं। उसी PR का सारांश दो बार बनता है, उसी फ़ाइल की समीक्षा दो बार होती है, उसी चेंजलॉग प्रविष्टि को दो बार बनाया जाता है — और हर बार, एजेंट उस उत्तर को फिर से बनाने की पूरी कीमत चुकाता है जिसे वह पहले ही बना चुका है। Runic इसके बजाय उत्तर को याद रखता है।

Runic क्या है

Runic उस किसी भी साधन के साथ रहता है जिसका एजेंट पहले से कार्य करने के लिए उपयोग करता है — MCP टूल कॉल सहित — एक वैकल्पिक जाँच के रूप में: “क्या मैंने पहले ही इस सटीक निर्णय को हल किया है?”

• एक कैश, एजेंट द्वारा पहले किए गए निर्णय के सटीक-मिलान, सामान्यीकृत हस्ताक्षर पर आधारित — { intent, params }, कभी कच्चा कार्य-पाठ नहीं, कभी तर्क का विवरण नहीं।
• एक लेजर, खर्च किए गए टोकन (एजेंट द्वारा रिपोर्ट किए गए) बनाम पुन: उपयोग पर बचाए गए टोकन लॉग करता है। केवल लेखा-जोखा, कोई प्रवर्तन नहीं।
• प्रति-सेशन दायरा। सेशनों/एजेंटों के बीच साझा करना बाद का चरण है, जब प्रति-सेशन पुन: उपयोग का महत्व सिद्ध हो जाए।

Runic जानबूझकर क्या नहीं है

• कोई निष्पादन परत नहीं। Runic कभी किसी क्षमता को कॉल नहीं करता, कुछ डिप्लॉय नहीं करता, या कोड नहीं चलाता — एजेंट स्वयं ऐसा करता है, जैसे वह पहले से करता है।
• कोई अनुमतियाँ या सैंडबॉक्सिंग प्रणाली नहीं। यदि कुछ निष्पादित नहीं होता, तो जाँचने के लिए कुछ नहीं है।
• कोई सिमैंटिक कैश नहीं। मिलान हल किए गए निर्णय पर सटीक होता है, न कि उस वाक्यांश पर अस्पष्ट जिसमें वह निर्णय आया था। यह सीमा क्यों बाधा है, शॉर्टकट नहीं, इसके लिए Scope देखें।

स्थापना

npm install @runic-labs/sdk

pnpm add @runic-labs/sdk

yarn add @runic-labs/sdk

bun add @runic-labs/sdk

लूप

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)

दो फ़ंक्शन ही पूरा एजेंट-उन्मुख अनुबंध हैं। इस रिपॉज़िटरी में बाकी सब कुछ इन दो कॉलों का समर्थन करता है।

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

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

वास्तविक संख्याएँ, अनुमान नहीं

Runic कभी स्वयं टोकन लागत नहीं मापता — एजेंट इसकी रिपोर्ट करता है, अपने प्रदाता द्वारा वास्तव में लौटाई गई किसी भी जानकारी का उपयोग करके। OpenRouter के विरुद्ध एक वास्तविक रन में, 48 निर्णय हल किए गए जिनमें से केवल 8 वास्तव में अद्वितीय थे:

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

इसे स्वयं पुन: उत्पन्न करने के तरीके के लिए Benchmarks देखें, साथ ही एक सिंथेटिक स्विप भी देखें जो दिखाता है कि यही तंत्र 10,000 निर्णयों पर भी काम करता है।

पैकेज

अगले चरण

• Quickstart — कुछ मिनटों में Runic को अपने एजेंट से जोड़ें
• How it works — हस्ताक्षर एल्गोरिदम और मिलान सटीक क्यों है
• Scope — पहले की निष्पादन-परत योजना से क्या हटाया गया, और क्यों

योगदान

Runic ओपन सोर्स है और योगदानों का स्वागत करता है। दिशानिर्देशों के लिए रिपॉज़िटरी में CONTRIBUTING.md देखें।

लाइसेंस

MIT