Lár: The PyTorch for Agents — The First EU AI Act-Ready Agent Execution Engine

Lár — The First EU AI Act-Ready Agent Execution Engine

The EU AI Act enforcement deadline is August 2026. Teams building AI agents in finance, healthcare, legal, and enterprise need to prove to regulators exactly what their agent did, why, and what it cost — on every run. Existing frameworks cannot do this. Lár can.

Lár is a ground-up agent execution engine where auditability is structural, not an add-on. Every design decision — deterministic graphs, step-level state diffs, cryptographic audit trails, topology validation, human oversight primitives — exists to satisfy EU AI Act requirements out of the box.

[!NOTE] Lár is NOT a wrapper. It does not wrap LangChain, OpenAI Swarm, or any other library. It is a standalone, dependency-lite Python engine optimized for "Code-as-Graph" execution.

The 12 EU AI Act Compliance Primitives

Lár ships a complete Enterprise Compliance Backbone — all 12 primitives required for a conformity assessment under Nannini et al. (2026), the definitive compliance architecture paper for AI agents under EU law:

Read the EU AI Act Deep Dive → | Nannini et al. (2026) Full Mapping →

See It Running: The Finance Showcase

One command runs a live SME credit decision through all 12 primitives and produces three HMAC-signed audit artefacts:

python examples/compliance/22_eu_ai_act_finance_showcase.py

Every step produces a real Article 12 causal trace, a real Article 14 AuthorityLedger record, and a real Step 9 action inventory — all HMAC-SHA256 signed. PII is stripped before signing.

This is the difference. Every step, every key written, every node that touched state — recorded. No guesswork, no external tooling required.

Full showcase breakdown — execution trace, real JSON artefacts, 12-step coverage map →

Open-source vs. enterprise: All 12 compliance primitives (BranchTriageNode, BiasFilterNode, RiskScorerNode, CredentialVault, etc.) are in lar.compliance and fully open-source under Apache 2.0. The finance showcase uses build_and_run from lar.enterprise, a convenience wrapper in the enterprise tier. Open-source users assemble the same pipeline from primitives — the step-by-step guide walks you through it: Build a Compliant Agent from Scratch →

How It Works: The "Glass Box"

Lár runs one node at a time, yielding a structured audit entry after every step. The execution model is a Python generator — each yield contains the state before, the state diff, token usage, the rendered prompt, and the outcome.

This means:

1. Instant Debugging: The exact node that failed, the exact data it received, the exact error — all in the log.
2. Built-in Auditing: A complete, immutable history of every decision and token cost, by default, on every run.
3. Deterministic Control: Explicit graphs, not probabilistic chat rooms. The same input produces the same execution trace.

Why Lár vs. LangChain / CrewAI

LangGraph crashes at Step 25 on a 60-node graph:

CRASH CONFIRMED: Recursion limit of 25 reached without hitting a stop condition.
LangGraph Engine stopped execution due to Recursion Limit.

See: examples/comparisons/langchain_swarm_fail.py

Build a Compliant Agent from Scratch

New to Lár? The step-by-step guide walks you through wiring every compliance primitive — from credential vault to HMAC-signed audit artefacts — starting from a blank file. Written for both engineers and AI assistants.

Read the guide → | Live showcase →

Installation

pip install lar-engine

Or from source:

git clone https://github.com/snath-ai/lar.git
cd lar
poetry install

Create a .env file with your model API keys:

GEMINI_API_KEY="..."
OPENAI_API_KEY="..."
ANTHROPIC_API_KEY="..."

Quick Start

pip install lar-engine
lar new agent my-bot
cd my-bot
python agent.py

The @node Decorator (Low Code)

from lar import node, GraphExecutor

@node(output_key="summary")
def summarize_text(state):
    text = state["text"]
    return my_llm.generate(text)

A Full Agent in 10 Lines

from lar import LLMNode, RouterNode, GraphExecutor

classify = LLMNode(model_name="gpt-4o", prompt_template="Classify: {input}", output_key="category")
route = RouterNode(decision_function=lambda s: s.get("category"), path_map={"A": node_a, "B": node_b})
classify.next_node = route

executor = GraphExecutor()
for step in executor.run_step_by_step(classify, {"input": "Hello"}):
    print(f"Step {step['step']} ({step['node']}): {step['outcome']}")

Core Primitives

Universal Model Support

Lár is built on LiteLLM — switch providers by changing one string. Zero refactoring.

# Cloud
node = LLMNode(model_name="gpt-4o", ...)
node = LLMNode(model_name="gemini/gemini-2.5-pro", ...)
node = LLMNode(model_name="claude-opus-4-6", ...)

# Local (Ollama)
node = LLMNode(model_name="ollama/phi4", ...)
node = LLMNode(model_name="ollama/deepseek-r1:7b", ...)

Read the Full LiteLLM Setup Guide →

Reasoning Models (System 2 Support)

Native support for DeepSeek R1, OpenAI o1, and Liquid. <think> tags are first-class citizens — extracted and saved to run_metadata, keeping the main context window clean.

node = LLMNode(
    model_name="ollama/deepseek-r1:7b",
    prompt_template="Solve: {puzzle}",
    output_key="answer"
)
# state['answer'] = "The answer is 42."
# log['metadata']['reasoning_content'] = "<think>First, I calculate...</think>"

Resumable Graphs

Most frameworks cannot reliably resume a crashed execution — not because the feature is missing, but because their routers are probabilistic. On retry, the LLM may branch differently. The "resume" is actually a new run that happens to start with the same input.

Lár's routers are pure Python functions. Same state in, same decision out — deterministically. When Lár resumes at Step 47, it takes exactly the path Step 47 would have taken. The resumption is exact, not approximate.

The GraphExecutor is a Python generator that yields after every node. GraphState is a plain dict — always serialisable, always decoupled from the engine. The causal trace written on every run is not just an audit log; every entry is a resumption checkpoint.

At 10,000 runs/day with 40% transient failure rate → $9.48/day saved.

The same property powers HumanJuryNode: the graph halts before an irreversible action, the process can be killed, and when the human responds — hours later if needed — execution resumes from exactly that node with exactly that state. This is what EU AI Act Art. 14 requires in practice.

See: examples/patterns/9_resumable_graph.py

Adaptive Graphs

When graph structure cannot be known at author-time, AdaptiveNode composes a validated subgraph at execution time.

• LLM generates a GraphSpec (JSON)
• TopologyValidator checks: cycle detection, tool allowlist, structural integrity
• Validated subgraph is injected into the live execution path
• Every spec is logged to the Causal Trace (Art. 3(23))

See: examples/adaptive/

Compliance & Safety

[!IMPORTANT] Who is the "Provider"? Under the EU AI Act (Art. 3), Lár is a software component, not an AI system. The organisation deploying a high-risk agent is the legal Provider. Lár provides the 12 architectural primitives to generate the evidence (audit logs, manifests, oversight records) required for a conformity assessment.

[!WARNING] Legal Disclaimer: Lár is open-source infrastructure, not legal advice. Using Lár does not automatically guarantee compliance. Organisations are solely responsible for legal review and conformity assessments.

What Lár solves:

• Cryptographic causal traces for every decision (Art. 12)
• Hardware-level routing to human approval before high-risk actions (Art. 14)
• Automated external action inventory for adjacent legislation (Step 9)

What Lár cannot solve:

• Model bias or unsuitability — if you plug in a biased model, Lár records the biased decision accurately; liability remains with the organisation
• Human negligence — a HumanJuryNode that is rubber-stamped will fail an audit for negligent oversight
• Data provenance — Lár cannot guarantee training data was legally acquired

Cryptographic Audit Logs

from lar import GraphExecutor

executor = GraphExecutor(
    log_dir="secure_logs",
    hmac_secret="your_enterprise_secret_key"
)
# Run your agent normally. Every log is HMAC-SHA256 signed.

Verify for auditors:

python examples/compliance/11_verify_audit_log.py secure_logs/run_xyz.json your_secret_key
# [+] VERIFICATION SUCCESSFUL  or  [-] VERIFICATION FAILED

Compliance pattern library:

• 8_hmac_audit_log.py — Basic HMAC authentication
• 9_high_risk_trading_hmac.py — Algorithmic Trading / SEC
• 10_pharma_clinical_trials_hmac.py — FDA 21 CFR Part 11
• 11_verify_audit_log.py — Standalone auditor script

Example Library

1. Basic Primitives (examples/basic/)

2. Core Patterns (examples/patterns/)

3. Reasoners & Comparisons (examples/reasoning_models/, examples/comparisons/)

4. Compliance & Safety (examples/compliance/)

5. High Scale & Advanced (examples/scale/, examples/advanced/)

6. Adaptive Execution (examples/adaptive/)

See the Adaptive Graphs Docs →

Showcase Projects

• snath-ai/DMN — A complete cognitive architecture built on Lár: bicameral mind (Fast/Slow), sleep cycles, episodic memory, catastrophic forgetting solved architecturally.
• snath-ai/Lar-JEPA — Universal model routing: LLMs, JEPA world models, diffusion models as first-class routable nodes in the same graph.
• snath-ai/rag-demo — Self-correcting RAG agent with a local vector database.

Agentic IDE Support

Lár is designed for Cursor, Windsurf, and Antigravity. Reference these files to make your IDE an expert Lár architect:

1. @lar/IDE_MASTER_PROMPT.md — strict typing rules and "Code-as-Graph" philosophy
2. @lar/IDE_INTEGRATION_PROMPT.md — generate production-ready API wrappers in seconds
3. @lar/IDE_PROMPT_TEMPLATE.md — fill in your agent's goal and ask the IDE to implement it

Show Your Agents are Auditable

[![Glass Box Ready](https://img.shields.io/badge/Auditable-Glass%20Box%20Ready-54B848?style=flat&logo=checkmarx&logoColor=white)](https://docs.snath.ai)

Author

Lár was created by Aadithya Vishnu Sajeev.

Lár is open-source. If this project helps you, consider supporting its development: Sponsor on GitHub →

Contributing

Read our Contribution Guidelines to report bugs, submit pull requests, and propose new features.

License

Lár is licensed under the Apache License 2.0. Free to use in personal, academic, or commercial projects. Retain the LICENSE and NOTICE files in any distribution.