DEV Community: bozoinc

Loops vs Graphs: Why Agent Architecture Needs Both (and a Compiler Between Them)

bozoinc — Wed, 26 Aug 2026 00:09:51 +0000

The False Dichotomy

 The agent ecosystem is split into two camps:

 Camp Loops (Boris Cherny, OpenAI Agents SDK, LangGraph):
 > "Agents are loops. Plan → act → observe → repeat. The loop is the atomic unit."

 Camp Graphs (Steve Yegge, Gas Town, LangGraph DAGs, CrewAI):
 > "Agents are graphs. Nodes are agents/tools. Edges are handoffs. The graph is the
 architecture."

 Both are right. Both are incomplete.
 What Loops Get Right

 Loops capture temporal behavior — the iterative, self-correcting nature of agent work:
 - Replanning on failure (AdaPlanner, ReAct)
 - Budget enforcement (token caps, step limits, cost ceilings)
 - Verification gates (process reward models, extraction floors)
 - Learning loops (feedback → lessons → advisory → suppress)

 A loop is a control structure. It says: keep going until condition X.
 What Graphs Get Right

 Graphs capture structural composition — how capabilities connect:
 - Handoffs (peer-to-peer control transfer)
 - Parallel execution (swarms, polecats, fan-out/fan-in)
 - Supervision trees (Erlang/OTP-style restart strategies)
 - Provenance (who called whom, with what context)

 A graph is a dependency structure. It says: A feeds B, B feeds C, C can restart A.
 The Missing Layer: A Compiler Between Repos and Runtime

 Here's what neither camp addresses: Where do the nodes come from?

 Today:
 - You find a repo on GitHub
 - You hope it implements what it claims
 - You wire it into your graph/loop
 - You pray it works

 There's no verification layer. No SBOM. No attestation. No provenance.
 HURCULES: The Compiler Between Repos and Runtime

 HURCULES sits between the repository and the agent runtime:

 GitHub Repository → HURCULES → Verified Capability Package → Agent Runtime (Loop or Graph)

 It doesn't care if your runtime is a loop or a graph. It produces verified capabilities that
 work in either.
 What HURCULES Compiles

 | Input                         | Output                                            |
 |-------------------------------|---------------------------------------------------|
 | Raw repo (any language)       | Deterministic map (file tree, deps, entry points) |
 | Map + LLM analyst             | Candidate capabilities with file citations        |
 | Candidates + Devil's Advocate | Challenged, evidence-backed capabilities          |
 | Challenged + Human approval   | Verified capability package (registry entry)      |
 The Package Contains
 - Capability spec (name, description, interface)
 - File-level evidence (exact files implementing each claim)
 - Provenance (source repo, commit hash, timestamp)
 - Approval trail (who approved, when, what they saw)
 - License classification (permissive/copyleft/proprietary/unknown)
 - Security scan (secrets, injection patterns, malicious patterns)
 Loops Need Verified Nodes

 A loop that runs on unverified capabilities is a liability:
 - The loop replans, but the capability was never real
 - The budget enforces cost, but the capability is malicious
 - The verification gate passes, but the evidence was hallucinated

 HURCULES gives loops verified nodes. The loop becomes a control structure over attested
 capabilities.
 Graphs Need Verified Edges

 A graph with unverified nodes is a supply chain attack waiting to happen:
 - Node A hands off to Node B
 - Node B was never verified
 - The edge carries malicious context
 - Supervision restarts Node B, but the capability is still broken

 HURCULES gives graphs verified nodes with provenance. The graph becomes a composition of
 attested capabilities.
 The Architecture: Compiler + Runtime

 ┌─────────────────────────────────────────────────────────────┐
 │                     AGENT RUNTIME                            │
 │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
 │  │    Loop     │  │    Graph    │  │  Hybrid     │          │
 │  │  (control)  │  │ (structure) │  │  (both)     │          │
 │  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘          │
 └─────────┼────────────────┼────────────────┼──────────────────┘
           │                │                │
           └────────────────┼────────────────┘
                            ▼
               ┌─────────────────────────┐
               │   VERIFIED CAPABILITY   │
               │       REGISTRY          │
               │  (HURCULES OUTPUT)      │
               └────────────┬────────────┘
                            │
                            ▼
               ┌─────────────────────────┐
               │      HURCULES           │
               │  (REPO → CAPABILITY)    │
               │  map → analyst →        │
               │  advocate → consolidate │
               │  → compile → approve    │
               └────────────┬────────────┘
                            │
                            ▼
               ┌─────────────────────────┐
               │    GITHUB REPOSITORIES  │
               │   (raw, untrusted)      │
               └─────────────────────────┘

 Why This Changes Everything
 For Loop Builders
 - Your loop never runs on hallucinated capabilities
 - The extraction floor catches empty/unparseable output
 - The devil's advocate challenges every claim
 - Cost routing picks the right model tier for the job
 For Graph Builders
 - Your nodes have provenance (source, commit, approver)
 - Your edges carry verified context (not raw LLM output)
 - Your supervision tree can audit the capability, not just the process
 For Enterprise
 - SBOM-for-Agents is now real
 - Compliance teams can audit the supply chain
 - Security teams can block unapproved capabilities

Part 2: Loops vs Graphs: Why Agent Architecture Needs Both (and a Compiler Between Them)

 - Legal teams can verify license compliance
 The Honest Ceiling

 We don't claim perfection. HURCULES's semantic recall is ~0.10 against human gold labels.

 We publish this number. Every release.

 Because the trust layer must be honest about its own limits. A trust layer that lies about
 its recall is worse than no trust layer.
 What's Next

 1. R1: Extraction quality lift (gold-label alignment → recall ~0.20+)
 2. R2: Private-repo ingestion + Authentik OIDC (Pro tier)
 3. R3: Hosted dashboards + SBOM export (Enterprise tier)
 4. Registry growth: 26 → 60+ verified capabilities
 5. Runtime integrations: Native Hermes, LangChain, CrewAI support
 The Thesis

 The agent ecosystem doesn't need another loop framework or another graph framework.

 It needs a verified capability supply chain.

 HURCULES is that supply chain. Loops and graphs are the consumers.

 Try it: pip install hurcules → hurcules ingest --repo <any-repo>

 The ceiling report is at data/ceiling-report.json. The evidence is in every package.

 Measured, not promised.

SBOM-for-Agents: The Missing Trust Layer for Agent Supply Chains

bozoinc — Tue, 25 Aug 2026 23:41:00 +0000

Introduction

 Software Bill of Materials (SBOMs) are now a standard requirement for enterprise software.
 Executive Order 14028 mandated them for federal procurement. Every major enterprise now
 asks: What's in this software? Where did it come from? Is it safe?

 Yet for AI agents, there is no equivalent. When an agent runtime loads a "capability" from a
 GitHub repository, it has no way to verify:
 - Is this capability actually implemented in the repo?
 - What files support this capability?
 - Who approved this capability for use?
 - Does the license allow this use?
 - Are there security risks (prompt injection, secrets leakage, malicious code)?

 This is the trust gap in agent supply chains. HURCULES fills it.
 The Problem: Agents Are Flying Blind

 Agent frameworks (LangChain, CrewAI, AutoGen, Hermes, Semantic Kernel) let you load
 capabilities from GitHub repos with a single line of code:

 python
 Example: LangChain tool from GitHub
 from langchain.tools import load_tool
 tool = load_tool("github.com/owner/repo")

 But this is dangerous. The agent runtime has no way to know:
 - Does the repo actually contain the claimed capability?
 - What files implement it?
 - Who reviewed it?
 - Is the license compatible?
 - Are there security risks?

 This is like installing a Python package without knowing its dependencies or
 vulnerabilities. It's a security and compliance nightmare waiting to happen.
 The Solution: SBOM-for-Agents

 HURCULES is the SBOM-for-Agents: a deterministic compiler that turns any repository into a
 verified, provenance-tracked, human-approved capability package.
 How It Works

 1. Deterministic Mapping: HURCULES analyzes the repo without executing its code
 (hostile-by-default sandbox).
 2. Capability Extraction: It identifies candidate capabilities (e.g., "Workflow Execution
 Engine").
 3. Evidence Collection: For each capability, it collects file-level evidence (e.g.,
 "src/workflow.py implements this").
 4. Devil's Advocate: A separate agent challenges each claim (e.g., "Is this evidence
 sufficient?").
 5. Human Approval: A human reviews and approves the capability package.
 6. Provenance Tracking: Every capability is registered with a unique ID, source repo, commit
 hash, and approval timestamp.
 Example: Archon Teardown

 HURCULES analyzed coleam00/Archon (1,351 files) and produced 5 verified capabilities with
 file-level evidence:

 Capability: Workflow Execution Engine
 Confidence: 0.96
 Evidence: src/workflow_engine.py, src/executor.py
 ────────────────────────────────────────
 Capability: Adapter System
 Confidence: 0.94
 Evidence: src/adapters/base.py, src/adapters/registry.py
 ────────────────────────────────────────
 Capability: CLI
 Confidence: 0.95
 Evidence: src/cli/main.py, src/cli/commands.py
 ────────────────────────────────────────
 Capability: Isolation/Sandboxing
 Confidence: 0.92
 Evidence: src/sandbox/docker.py, src/sandbox/limits.py
 ────────────────────────────────────────
 Capability: Web Dashboard
 Confidence: 0.90
 Evidence: src/dashboard/app.py, src/dashboard/routes.py

 Honest ceiling: Extraction recall 0.0 / semantic ~0.10 vs. human gold labels — "measured,
 not promised."
 Why This Matters
 For Enterprise
 - Compliance: Prove to auditors that your agents only use approved, licensed, and secure
 capabilities.
 - Security: Detect prompt injection, secrets leakage, or malicious code before deployment.
 - Trust: Know exactly where each capability came from and who approved it.
 For Developers
 - Safety: Load capabilities from GitHub without executing untrusted code.
 - Evidence: See exactly which files implement a capability.
 - Provenance: Track who approved a capability and when.
 For the Ecosystem
 - Standardization: A common format for capability packages (like PyPI for agents).
 - Interoperability: Capabilities that work across Hermes, LangChain, CrewAI, AutoGen.
 - Trust: A verifiable supply chain for agent capabilities.
 The Road Ahead

 HURCULES is live today as an open-source tool (MIT license). The honest ceiling (0.08-0.10
 recall) is published as proof of discipline — no hype, just measured progress.
 Next Steps
 1. Improve extraction recall: Gold-label granularity alignment + stronger analyst
 calibration.
 2. Expand the registry: More repos → more capabilities.
 3. Integrate with agent runtimes: Native support in Hermes, LangChain, CrewAI.
 4. Enterprise features: Private-repo ingestion, hosted dashboards, SBOM export.
 Call to Action

 - Try HURCULES: pip install hurcules and analyze a repo.
 - Contribute: Issues and PRs welcome.
 - Spread the word: Share this with teams building agentic systems.

 The agent ecosystem needs SBOM-for-Agents. Let's build it together.

 This analysis was produced by HURCULES analyzing itself. The full ceiling report is at
 data/ceiling-report.json. The Archon teardown is at content/archon-teardown.json.