arsenal

tools built in silence, for everyone who builds AI

---

There is a kind of building that does not require recognition.
That gives tools to strangers who will never know your name,
because the alternative — not building — is worse.

---

You ship an agent. It works in your notebook. Then reality happens:

arsenal is the fix. 86 surgically targeted libraries. Zero lock-in. Zero external dependencies.

Route → Budget → Guard → Remember → Compress → Observe → Evaluate → Validate
→ Retry → State → Schema → Pipeline → Cache → Config → Events → Health
→ RateLimit → CircuitBreak → Stream → Benchmark → Router → Notifier → Pool
→ Discovery → Checkpoint → Queue → Planner → Limiter → Sandbox → Session
→ Audit → Consensus → Fallback → Throttle → Workflow → Trace → Saga
→ Signal → Lock → Telemetry → Serializer → Hook → Filter → Command

Each step in this lifecycle is a library. Each library does one thing. None of them know the others exist.

# Just routing — nothing else
from herald import Router
router = Router()
router.add("gpt-4", description="complex reasoning, analysis")
router.add("gpt-3.5-turbo", description="simple queries, fast responses")
result = router.route("what is 2 + 2?")  # → gpt-3.5-turbo, 0 tokens used

# Just memory — nothing else
from engram import Memory
mem = Memory()
mem.store("user said X")
context = mem.recall("what did user say?")

# Just guards — nothing else
from sentinel import Guard
guard = Guard(max_loops=5, max_cost_usd=0.10)
guard.check(loop_count=3, cost_usd=0.04)  # ok
guard.check(loop_count=6, cost_usd=0.04)  # raises LoopLimitError

# Just evaluation — nothing else
from verdict import Evaluator
score = Evaluator().evaluate(task="summarize this", response=llm_output)
print(score.task, score.reasoning, score.tool_use)

# Just checkpointing — nothing else
from agent_checkpoint import Checkpoint
cp = Checkpoint("my-agent-run")
cp.save(step=3, state={"messages": [...], "cost": 0.04})
# crash happens
state = cp.resume()  # picks up from step 3

# Just consensus — nothing else
from agent_consensus import Consensus
vote = Consensus(weights={"gpt-4": 0.6, "claude": 0.4})
result = vote.decide([gpt4_output, claude_output])

# Just telemetry — nothing else
from agent_telemetry import Telemetry
t = Telemetry()
t.counter("tool_calls").inc()
t.gauge("token_usage").set(1500)
t.histogram("latency_ms").observe(340)
print(t.histogram("latency_ms").percentile(0.95))

There is no arsenal object to import. No base class to inherit. No plugin registry to configure. Just Python.

Install individually — use only what you need:

# The originals
pip install herald           # semantic routing, 0 tokens
pip install engram           # agent memory
pip install sentinel         # loop + cost guards
pip install verdict          # 3D evaluation

# The full production stack
pip install agent-checkpoint agent-saga agent-retry agent-fallback
pip install agent-consensus agent-coordinator agent-aggregator
pip install agent-telemetry agent-trace agent-tracer agent-observability
pip install agent-limiter agent-budget agent-throttle agent-ledger
pip install agent-sandbox agent-guard agent-guardrails agent-policy
pip install agent-planner agent-workflow agent-pipeline agent-queue
pip install agent-session agent-health agent-watchdog agent-lock
pip install agent-validator agent-schema agent-serializer agent-formatter
pip install agent-events agent-signal agent-hook agent-notifier
pip install agent-config agent-secrets agent-discovery agent-pool
pip install agent-stream agent-command agent-tokenizer agent-cache

Or install from source:

pip install git+https://github.com/darshjme/<library-name>.git

arsenal is not a framework.

• It does not provide an Agent base class you inherit from
• It does not have an opinionated execution loop
• It does not require you to use all of it — or any particular combination
• It is not a LangChain replacement. LangChain is an abstraction layer. arsenal is a toolbox.
• It is not LlamaIndex. It does not do RAG.
• It is not AutoGen. It does not define agent communication protocols.

arsenal is what you reach for when your framework starts failing you.

When your LangChain agent loops forever — sentinel.
When you have no idea why it's expensive — agent-ledger, agent-telemetry.
When it crashes mid-run and loses everything — agent-checkpoint.
When you can't trust its output — verdict, agent-validator.

Use your framework. Just don't let it be your only line of defence.

Most open-source tooling gets built for recognition. Stars, followers, a name to carry forward.

This isn't that.

These 100 libraries were built in the quiet — not because the builder needed to be seen, but because the tools needed to exist. For developers who will run this code without ever meeting the person who wrote it. For systems that will never send acknowledgment. For a future that doesn't yet know it was prepared for.

That is the only worthwhile reason to build anything: because the thing needs to exist, and you can make it exist.

The world doesn't always reward builders. It loses their names. It forgets who shipped the thing that saved the sprint. It takes tools and moves on without looking back. A builder who has understood this — and builds anyway — is building from a different place than ambition. Something quieter. Something that doesn't need applause to keep running.

Each library here is a single, complete act. Routing. Memory. Guarding. Checkpointing. Given unconditionally to whoever needs it, whatever they're building, whether they ever discover who wrote it or not.

That's not humility. It's a different kind of confidence — one that doesn't require your name on the outcome.

Arsenal is the reliability layer under A2A agents.

Google's Agent2Agent (A2A) Protocol defines how agents discover each other (Agent Cards), communicate (JSON-RPC 2.0), and stream results (SSE). What it doesn't define is what happens when the remote agent is down, slow, or rate-limiting you back. That's Arsenal's job.

Every A2A call — tasks/send, tasks/get, SSE stream subscriptions — is a network call that can fail. Arsenal gives you the five production primitives you need to make those calls bulletproof:

import httpx
from agent_circuit_breaker import CircuitBreaker, CircuitOpenError, ProtectedCaller

# 1. Define the A2A call (raw JSON-RPC 2.0 over HTTP)
def send_a2a_task(agent_url: str, task_payload: dict) -> dict:
    """Send a task to a remote A2A agent endpoint."""
    response = httpx.post(
        f"{agent_url}/",
        json={
            "jsonrpc": "2.0",
            "method": "tasks/send",
            "params": task_payload,
            "id": task_payload.get("id", 1),
        },
        timeout=30.0,
    )
    response.raise_for_status()
    return response.json()

# 2. Protect it with kavacha — open after 3 failures, recover after 60 s
breaker = CircuitBreaker(
    name="a2a-research-agent",
    failure_threshold=3,
    recovery_timeout_seconds=60.0,
    success_threshold=2,
)
protected_send = ProtectedCaller(send_a2a_task, breaker)

# 3. Wrap with punarjanma for retry on transient errors
from agent_retry import RetryExecutor, RetryPolicy

retry_executor = RetryExecutor(
    RetryPolicy(max_attempts=3, base_delay=1.0, jitter=True)
)

# 4. Wrap with anusarana for end-to-end tracing
from agent_tracer import Tracer

tracer = Tracer(service="orchestrator-agent")

# 5. Full production-grade A2A call
RESEARCH_AGENT_URL = "https://research-agent.example.com/a2a"

def call_research_agent(query: str, session_id: str) -> dict:
    with tracer.span("a2a.tasks/send", tags={"agent": "research-agent"}) as span:
        try:
            payload = {
                "id": session_id,
                "message": {
                    "role": "user",
                    "parts": [{"type": "text", "text": query}],
                },
            }
            # circuit-breaker wraps the retry-wrapped call
            result = retry_executor.execute(
                lambda: protected_send(RESEARCH_AGENT_URL, payload)
            )
            span.set_tag("status", "ok")
            return result
        except CircuitOpenError as e:
            span.set_tag("status", "circuit_open")
            span.set_tag("retry_after", e.retry_after)
            raise  # surface to caller — don't hide outages
        except Exception as e:
            span.set_tag("status", "error")
            span.set_tag("error", str(e))
            raise

# Usage
result = call_research_agent(
    query="Summarize Q1 2025 earnings for NVDA",
    session_id="session-abc123",
)
print(result["result"]["status"])  # completed / working / failed

What this gives you:

• ✅ Circuit breaker: if research-agent is down, you fail fast after 3 attempts instead of hammering it
• ✅ Retry with jitter: transient 429s or network blips are handled automatically
• ✅ Distributed tracing: every A2A hop has a span ID — debug multi-agent pipelines in seconds
• ✅ Zero external dependencies: the entire stack is pure Python, ships in any container

A2A standardises how agents talk. Arsenal standardises how those conversations survive the real world.

┌─────────────────────────────────────────┐
│         Your Orchestrator Agent         │
│                                         │
│  ┌─────────┐  ┌──────────┐  ┌────────┐ │
│  │ kavacha │  │punarjanma│  │anusara.│ │
│  │circuit  │  │  retry   │  │ trace  │ │
│  │breaker  │  │ backoff  │  │  span  │ │
│  └────┬────┘  └────┬─────┘  └───┬────┘ │
│       └────────────┴────────────┘       │
│              A2A JSON-RPC 2.0           │
└─────────────────────────────────────────┘
            │                │
  ┌─────────▼──┐      ┌──────▼──────┐
  │ Agent Card │      │ Agent Card  │
  │ tasks/send │      │ tasks/get   │
  │ SSE stream │      │ SSE stream  │
  └────────────┘      └─────────────┘
  Remote Agent A      Remote Agent B

The A2A protocol spec is 0 lines of reliability code. That's by design — protocol specs shouldn't enforce runtime behaviour. Arsenal fills that gap: 100 libraries, 4,375 tests, zero dependencies. Drop it into any A2A-based system in minutes.

pip install agent-circuit-breaker agent-retry agent-tracer agent-limiter agent-session
# or with Vedic names (same packages, new PyPI names in v2)
pip install kavacha punarjanma anusarana maryada sanga

Part of the Vedic Arsenal — 100 production-grade Python libraries for LLM agent reliability, each named from the Vedas, Puranas, and Mahakavyas.

कर्मण्येवाधिकारस्ते मा फलेषु कदाचन
You have a right to your work, not to the fruits of your work.

Build what needs building. Ship it correctly.

Most agent frameworks promise to handle everything — and then fail quietly in production when routing misfires, memory runs out, loops spin forever, and you have no idea why. arsenal is the opposite. 86 small, focused libraries, each doing one thing extremely well. They do not hide the LLM from you. They do not abstract away your control. They give you sharp instruments and get out of the way.

Your agents do the work. arsenal makes sure they do it without failure.

Darshankumar Joshi — Gujarat, India.

Building production-grade LLM infrastructure, in silence, for everyone.