AnthonyAlcaraz

@anthonyalcaraz source repo

51 skills
0 followers
6 hours ago last updated

▌
Bi Temporal Edge · anthonyalcaraz bundle
Bi-temporal edge primitive for agentic graph memory. Tracks two independent time dimensions per relationship: when the relationship was VALID in the domain (valid_from / valid_until) and when the system LEARNED about it (ingested_at). Enables point-in-time queries like "What was the EC2 instance type for service-checkout-api at 2026-03-15T08:00Z when the outage occurred?" — answerable even after the config has changed. Graphiti / Zep production pattern (Ch4). Use when memory must answer "what did we know and when did we know it" questions: incident reconstruction, audit, root-cause forensics, regulated environments. NOT for ephemeral cache state (use TTL), NOT for append-only event logs (use kafka-style log, no validity window needed), NOT for single-point- in-time configs (use a plain dict).

0
installs
▌
Hierarchical Memory · anthonyalcaraz bundle
Three-tier hierarchical memory (Letta / MemGPT pattern) — core / recall / archival. Core holds a small, fast, frequently-accessed working set (e.g. core_limit=2000 tokens). Recall holds raw interaction history for "what did we talk about yesterday" questions. Archival holds effectively unlimited overflow, still searchable. Make forgetting and archiving explicit design choices, not afterthoughts. Use when an agent must feel consistent across long sessions and the context window is the scarcest resource. NOT for one-shot agents (no persistence needed), NOT for event logs (use append-only kafka-style), NOT when every fact is equally important (then a flat store is correct).

0
installs
▌
Letta Failure Modes · anthonyalcaraz bundle
Reviewer skill: diagnose an agent's memory architecture against the 8 Letta Leaderboard failure modes (Ch4). Takes a memory snapshot (or a description of the architecture) and reports which failure modes are present, with concrete evidence and recommended fixes. Use BEFORE shipping any memory implementation to production and BEFORE root-causing why a deployed agent "forgets" or "drifts." NOT a benchmark (does not produce a single accuracy number), NOT a substitute for production observability (this is a static diagnostic, not a runtime monitor).

0
installs
▌
Memory Consolidation · anthonyalcaraz bundle
Consolidation pipeline — turn noisy raw episodes into durable knowledge (Agentic GraphRAG Ch4, Example 4-5 + Example 4-13). Four steps: cluster related episodes by topic, summarize each cluster into one consolidated fact, create the consolidated node, and maintain a provenance chain back to the source episodes so "how do you know that?" is answerable. Clusters below a minimum size (default 3) are skipped — not enough examples to generalize. Adds the sleep-time-compute discipline: run consolidation during idle periods, never on the synchronous response path, and pre-compute inferences that anticipate likely queries. Use when an agent accumulates redundant, overlapping experiences that must compress into stable, queryable patterns. NOT for one-shot agents (nothing to consolidate), NOT for the response hot path (consolidation is a background/idle job), NOT for facts that must stay individually addressable (consolidation merges them).

0
installs
▌
Rrf Hybrid Retrieval · anthonyalcaraz bundle
Reciprocal Rank Fusion (RRF) hybrid retrieval across 4 parallel channels — semantic / keyword / graph-traversal / temporal — followed by cross-encoder rerank and token-budget filter (HINDSIGHT, Latimer et al. 2025, cited in Ch4). Rank-based fusion means scores don't need calibration across channels; absent items contribute nothing; items high in multiple lists surface naturally. Use when memory must answer queries that mix conceptual / exact-id / connected-entity / recent-event facets. NOT for single-channel retrieval (just use that channel), NOT for systems where one channel dominates (the fusion is overhead).

0
installs
▌
Dual Graph Router · anthonyalcaraz bundle
Route an incoming request to the VERTICAL knowledge graph (what the agent knows — a single relationship/temporal traversal), the HORIZONTAL workflow graph (how the agent acts — a decomposed multi-step process), BOTH (a workflow whose nodes query the knowledge graph and write results back), or UNROUTABLE (neither fits — ask for clarification). Implements the central dual-graph distinction of Agentic GraphRAG Ch2 and the "Where the Two Graphs Meet" bidirectional interaction. Use when an agent receives an on-call request and must decide whether it is a knowledge lookup or a process. NOT for building the workflow DAG itself (that is harness-node-splitter / investigation-dag-planner), NOT for choosing a graph data model (that is graph-model-selector), NOT for requests where the structure is already fixed by a hardcoded pipeline.

0
installs
▌
Execution Graph · anthonyalcaraz bundle
Foundational Ch7 primitive: an immutable, queryable graph of every decision / retrieval / tool-call / LLM-call an agent made for a specific query. Nodes are atomic operations carrying input/output/timestamp/ latency/cost/tokens; edges are TRIGGERED relationships establishing the full causal lineage. Two-phase write — create-on-start (captures structure even on failure), fill-on-complete (latency + cost + output). Enables diagnostic queries that flat logs cannot answer ("every tool invocation that followed an LLM call with confidence < 0.7 and resulted in latency > 3s"). Use BEFORE building any Ch7 evaluation or self-evolution machinery — it is the substrate everything else depends on. NOT for one-shot single-call agents (no graph to trace), NOT for systems where observability already lives in OpenTelemetry-to-graph pipeline (you have it already).

0
installs
▌
Context Failure Classifier · anthonyalcaraz bundle
Classify an observed agent symptom into Ch1's context-failure taxonomy. Given a sentence describing what an agent did wrong, name the agent-level failure mode (action blindness / memory fragmentation / planning paralysis / context drift / tool chaos), the architectural root cause among the five fatal flaws, and the curing graph capability. Batch mode aggregates a post-mortem's symptoms into a prioritized cure list, surfacing Ch1's cascade point — that the failure modes reinforce one another. Use to triage why an enterprise agent is failing and decide what to build next. NOT for general bug triage (it only knows retrieval/context failures), NOT for model-quality issues (Ch1: the flaws are architectural, not the model).

0
installs
▌
Harness Node Splitter · anthonyalcaraz bundle
Split a workflow description into constrained harness nodes using the chapter's rule "nodes differ by tool surface, not by prompt." Given candidate operations each with a declared tool set, merge the ones whose tool surfaces overlap >= 80% (prompt variations of one role) and split the ones with distinct tool surfaces (different roles), then emit the per-node constrained context scope the harness enforces (tool surface + memory reads/writes + input/output contract). Implements the RedAI scanner-vs-validator distinction and the 80%-overlap Tip from Agentic Graph RAG Ch2. Use when turning a horizontal-workflow sketch into executable nodes. NOT for scheduling nodes into parallel phases (that is investigation-dag-planner, Ch5), NOT for deciding vertical-vs-horizontal (that is dual-graph-router), NOT for selecting which tools a query needs (that is rag-mcp-tool-selection, Ch6).

0
installs
▌
Enterprise Readiness Scorer · anthonyalcaraz bundle
Score a proposed or deployed enterprise agent against the architectural requirements Ch1 argues are non-negotiable: absence of the five fatal flaws of naive vector RAG (context amnesia / relationship blindness / temporal ignorance / reasoning paralysis / tool chaos), calibration of the three agency dimensions (autonomy / action / authority), presence of the four emergent capabilities, and the decision-trace test that separates a real context graph from a relabeled search index. Produces a 0-100 score, a band (PRODUCTION-READY / PILOT-READY / PROTOTYPE / NAIVE-VECTOR), and a gap-closing recommendation per open flaw. Use before greenlighting an enterprise agent for production. NOT for ranking models (Ch1 says the flaws are architectural, not model-quality), NOT for consumer FAQ bots where vector RAG is a fine fit.

0
installs
▌
Graphiti Incremental Update · anthonyalcaraz bundle
Graphiti (Zep) incremental-update pattern (Ch4). When new content arrives, process only the new content — never re-process the entire graph. Pipeline: (1) extract entities from new episode, (2) entity-resolve against existing graph (dedupe by canonical name + alias + fuzzy match), (3) incremental- update — touch only the affected neighborhood, leave the rest of the graph unchanged. Keeps update latency O(new content) instead of O(full graph), enabling sub-second latency at millions-of-nodes scale. Use when memory graph grows continuously and full-graph re-embedding is impossibly expensive. NOT for one-shot batch ingestion (just process it once), NOT for static knowledge bases (no updates means no incremental anything).

0
installs
▌
Model Routing Selector · anthonyalcaraz bundle
Match model capability to task complexity across a horizontal workflow graph. Given a node, pick the cheapest model that meets its quality bar, using one of three routing strategies: static routing by node type, threshold-based cascading (FrugalGPT), or learned routing (RouteLLM / MixLLM). Re-derives the book's DevOps DEVOPS_MODEL_CONFIG from first principles and reports the blended cost reduction (~80%). Use when every node of an agentic pipeline runs on the same frontier model and the invoice is unsustainable. NOT for single-model systems, NOT for choosing WHICH graph model to use (that is graph-model-selector), NOT for measuring a policy after the fact (that is cost-performance-scorer).

0
installs
▌
Cost Performance Scorer · anthonyalcaraz bundle
Score a multi-model routing policy on cost versus quality using the two metrics that actually decide selective intelligence: cost per successful completion (not cost per token) and a per-node quality parity threshold with domain-specific failure weights. Wraps a NodeInvocation log, computes cost-per-success and p95 latency per node, and evaluates a candidate model against a per-node evaluation set drawn from production data. Use to justify or recalibrate a routing decision AFTER you have run traffic. NOT for deciding routing a priori (that is model-routing-selector), NOT for generic benchmarks (MMLU/HumanEval do not capture your alert taxonomy), NOT for latency/KV budgeting (that is kv-cache-latency-budgeter).

0
installs
▌
Subgraph Access Control · anthonyalcaraz bundle
Scope what each agent persona can see in a knowledge graph. Generates Neo4j fine-grained GRANT/DENY policy (traverse on node labels + relationship types, read on properties) per persona role, enforces security transparency (out-of-scope nodes are invisible, not access-denied), handles PII via the UUID-separation pattern with GDPR soft/hard erasure, and turns the Chapter-7 execution graph into a compliance artifact via governance metadata. Use for graph-backed agents where one unscoped query could traverse from a public catalog to employee records. NOT for relational row/table permissions, NOT for network/IAM policy, NOT for prompt-level guardrails (this governs graph reach).

0
installs
▌
Intervention Selector · anthonyalcaraz bundle
Ch7 self-evolution router: map a diagnostic report to exactly one intervention, deterministically and auditably, not as a per-engineer judgment call. Four branches in strict order: insufficient context -> RETRIEVAL_FIX, FORMAT_VIOLATION -> STRUCTURAL_CONSTRAINT, localized REASONING failure with intact knowledge -> PROMPT_REFINEMENT, everything else -> FINE_TUNE. A second axis ranks intervention types on the self-modification intensity hierarchy (prompt tuning lightest, weight adaptation middle, code modification heaviest). Ports Ch7 the select_intervention routing example exactly, thresholds tunable per the chapter Tip. Use AFTER a diagnostic report exists and you must choose the fix. NOT for producing the diagnosis itself (that is the Layer 0/1/2 evaluation pipeline), NOT for applying the fix (this routes; SEAL/TPT/Outlines apply).

0
installs
▌
Hindsight Epistemic Classifier · anthonyalcaraz bundle
Classify facts into HINDSIGHT's 4 epistemic networks (Latimer et al. 2025, cited in Ch4): World (objective external facts), Experience (agent's own first-person actions), Opinion (subjective beliefs with confidence), and Observation (synthesized entity summaries). The separation enables traceability — when users ask "how do you know that", the agent can distinguish evidence from inference from summary. Use when memory must support "how do you know" questions and the agent will be asked to justify its outputs. NOT for one-shot agents (no need to justify), NOT for storage-only systems (the classification is for retrieval-time reasoning, not just persistence).

0
installs
▌
Kv Cache Latency Budgeter · anthonyalcaraz bundle
Budget a specialist model fleet against the two production bottlenecks: KV-cache-bound concurrency and end-to-end latency. Computes how many concurrent users a GPU can host (peak KV per active user, not model size, is the binding constraint), proves that quantizing weights does not move that ceiling while KV compression (MEMENTO) does, estimates GPU speedups for graph analytics (cuGraph / nx-cugraph), and checks a multi-node workflow against the book's latency budget and the sub-2s target. Use when scaling a multi-model agent to real-time latency. NOT for model selection (that is model-routing-selector), NOT for cost/quality scoring (that is cost-performance-scorer), NOT for defining GPU terms (that is gpu-glossary-anchor).

0
installs
▌
Schema Evolution Migrator · anthonyalcaraz bundle
Keep a production knowledge graph healthy across schema evolution, node/edge lifecycle, incremental updates, and coordinated deployment. Emits N-1 compatible Neo4j-Migrations-style schema migrations, temporal-invalidation Cypher (bitemporal t_valid/t_invalid, invalidate-not-delete), LightRAG-style incremental merge from a deployment event, TTL/retention policy per node class, and a four-phase staged-rollout manifest coordinating schema + data + agent code with canary gates. Use when a graph-backed agent must ship changes to the graph and the code together without downtime. NOT for one-time graph creation, NOT for relational migrations (Flyway/Liquibase), NOT for model routing.

0
installs
▌
Four Layer Eval Cascade · anthonyalcaraz bundle
The Multi-Layered Evaluation Framework as a sequential diagnostic cascade that STOPS at the first failing layer. Layer 0 is a zero-shot hallucination gate (NLI grounding, catches 60-70% of hallucinations at under 5% of full-judge compute). Layer 1 is a context evaluator (binary sufficient/not). Layer 2 is a cognitive fault isolator (KNOWLEDGE vs REASONING). Layer 3 is the TIR-Judge (correctness times format times tool, MULTIPLICATIVE so a well-formatted wrong answer scores 0). The cascade emits a diagnostic report that names the failure mode, locates it by node, and prescribes an intervention. Use to autopsy a failed agent execution and route the fix (retrieval / prompt / fine-tune). NOT for one-shot single-call agents (no reasoning trace to isolate), NOT a replacement for the execution graph it reads from (build that first).

0
installs
▌
Eight Pillar Readiness Map · anthonyalcaraz bundle
Map an agentic-graph system's current capabilities across the eight pillars of Agentic GraphRAG Ch2 (knowledge representation, memory, reasoning, planning, tool orchestration, structured output, self-evolution, optimization), respect the chapter's layering (each pillar depends on the ones before it), flag dependency violations (a higher pillar claimed present while a lower one it requires is missing), report which of the five Chapter-1 flaws remain unsolved (per Table 2-1), and recommend the next pillar to build. Use when auditing an agent's production readiness or planning the build order. NOT for building any single pillar (each has its own chapter and skills), NOT for routing a request (that is dual-graph-router), NOT for a generic maturity model unrelated to the eight pillars.

0
installs
▌
Agent Constraint Triangle Scorer · anthonyalcaraz bundle
Score an agent configuration against Ch1's Agent Constraint Triangle — the three interconnected constraints (complexity management, tool orchestration, context utilization) that make agent design an inherently difficult operational problem. Given the agent's reasoning-chain length, tool-catalog size and disambiguity, and context budget vs. usage, produce a 0-100 pressure score and band per constraint, name which of Ch1's three cyclic trade-offs are active (complexity->tools->context, tools->context->complexity, context->complexity->tools), and give the minimal-but-sufficient recommendation for each stressed constraint. Use before scaling an agent's tools/steps/context to see which corner of the triangle will break first. NOT for model-quality issues (Ch1: the triangle is architectural), NOT for agents under ~10 tools with short chains where no corner is under pressure.

0
installs
▌
Loop Pipeline Router · anthonyalcaraz bundle
The conditional-edge routing that turns a validate node into a bounded self-correcting loop (Ch5 Loop Pipeline + Error-handling strategies, Examples 5-6/5-9). Consumes a validation result, an error severity (correctable vs fundamental), and a retry budget, and returns exactly one of: proceed, refine (loop back with a remaining retry), fallback (alternative strategy once retries are exhausted), or terminate-with-partial (fundamental error). The finite retry budget is the explicit bound that prevents infinite loops. Use when first-attempt success is unrealistic and validation can identify correctable errors — plan refinement, documentation-gap re-requests, transient-failure recovery. NOT for strict sequential pipelines with no feedback (use a sequential pipeline), NOT for parallel branch reconciliation (that is a merge/tree concern), NOT as a substitute for the validator itself (this routes on the validator's output; it does not validate).

0
installs
▌
Memory Consistency Model Selector · anthonyalcaraz bundle
Choose a memory consistency model PER agent-coordination operation — STRONG (linearizable), CAUSAL, READ-YOUR-WRITES, or EVENTUAL — by scoring the operation's requirements (shared authoritative state, conflict intolerance, staleness budget, collaboration, self-session continuity), per Ch4 "Memory consistency models for agent coordination". The chapter's rule: default to causal, escalate to strong only for irreversible decision points. Also flags cache-sharing divergence — an agent acting on a cached read older than a committed write it depends on. Use when designing shared memory for a multi-agent system, justifying a consistency choice, or auditing a stale- cache handoff. NOT for single-agent stateless systems (no coordination), NOT for picking a datastore product (this picks the model, not Redis-vs-etcd), NOT when the platform already mandates a consistency model (just adopt it).

0
installs
▌
Vector Vs Graph Retrieval Selector · anthonyalcaraz bundle
Recommend VECTOR / GRAPH / HYBRID retrieval for a query workload, grounded in Ch1's BenchmarkQED evidence for where vector RAG succeeds and where it collapses. Classifies the workload on the BenchmarkQED scope x type axes (local/global, data/activity), weighs multi-hop / temporal / associativity needs, domain structure, corpus scale, and latency, then returns a recommendation with the chapter's numbers (vector RAG ~90% on DataLocal vs 20-30% on ActivityGlobal; LazyGraphRAG +50-60% on multi-hop; EyeLevel 12% vs 2% accuracy drop at 100k pages). Includes the explicit larger-context- window rebuttal (the ~1M-token BenchmarkQED test) and surfaces GraphRAG's own costs. Use when choosing a retrieval architecture for an enterprise agent. NOT for tuning an existing pipeline's embeddings, NOT for consumer FAQ bots where vector RAG is already the right fit.

0
installs
▌
Workflow Agent Spectrum Classifier · anthonyalcaraz bundle
Place an AI system on Ch1's continuous workflow-agent spectrum instead of the false binary "is it an agent or not". Scores the three dimensions of agency (autonomy / action / authority) plus how predefined the execution path is, returns a spectrum position (0 = workflow, 1 = agent) and a band (WORKFLOW / BLENDED / AGENT), applies Ch1's action test (a system that cannot effect change is an assistant/advisor, not an agent), and reports the four emergent capabilities (autonomous decision-making, contextual understanding, strategic tool utilization, memory persistence). Accepts numeric dimensions or a free-text system description. Use to right-size an architecture — deterministic workflow, blended human-in-the-loop, or full agent. NOT for ranking model quality, NOT for systems with no LLM in the loop.

0
installs
▌
RAG MCP Tool Selection · anthonyalcaraz bundle
Select the top-K tools from a registry of 30+ MCP / AWS / internal-API tools for a given natural-language query, replacing MCP's tools/list dump with a RAG-style filter that reduces prompt tokens 50-70%. Three-step pipeline: retrieve / validate / format. Use when the agent has access to many tools and prompt bloat is killing response quality. NOT for cases with under 10 tools (just include them all), NOT a replacement for an MCP server (this filters what an MCP server exposes), NOT for one-off scripts where the toolset is known and fixed.

0
installs
▌
Skill Quality Evaluator · anthonyalcaraz bundle
Score a skill against SkillNet's five quality dimensions (safety, completeness, executability, maintainability, cost_awareness), compute a safety/executability-weighted composite, and gate skill retrieval so an agent pulls the most-relevant skill that ALSO clears a quality threshold. Use when a skill library has grown past a few dozen entries and retrieval is surfacing low-quality or unsafe skills alongside useful ones. NOT for routing (which skill matches this task? — that is rag-mcp-tool-selection), NOT for a library under ~20 curated skills (quality is still trivially auditable by hand), NOT a substitute for a security scanner (executability and safety scores are heuristics that flag review, not proofs).

0
installs
▌
Tool Primitive Selector · anthonyalcaraz bundle
Choose how to expose an agent capability — a command-line interface (CLI) vs a Model Context Protocol server (MCP) vs a Skill — by profiling the capability along the chapter's dimensions and scoring three primitives across six feature axes, per Ch6 "Choosing the Right Primitive: CLIs, MCPs, and Skills". The chapter's frame: three primitives, three audiences on a personal-to-enterprise gradient, and CONVERGENCE not competition — a single capability is often exposed as more than one, so the selector returns a primary recommendation AND an also_expose_as list. Use when deciding how to wrap a capability, or justifying a CLI-vs-MCP-vs-Skill choice in a design doc. NOT for RETRIEVING which tools to load at runtime (that is rag-mcp-tool-selection), NOT for picking a specific vendor product, NOT when the platform already mandates a primitive (just adopt it).

0
installs
▌
Three Graph Router · anthonyalcaraz bundle
Route an incoming record/fact into the correct graph of the Three-Graph Architecture (Ch3) — DOMAIN (trusted, entity-resolved single source of truth), LEXICAL (verbatim source text with provenance, the "retrieval" in RAG), or SUBJECT (LLM-extracted artifacts kept SEPARATE from domain until entity resolution links them). The router enforces the boundaries that make the architecture work — an extraction can NEVER be written straight into the domain graph; it must enter subject and link via CORRESPONDS_TO above a confidence threshold (default 0.85). Use when ingesting mixed structured + unstructured data into an agent knowledge graph, when designing the separation between trusted and extracted knowledge, or when preventing extraction errors from contaminating ground truth. NOT for single-source trusted data (no separation needed), NOT for the entity- resolution matching algorithm itself (this gates the link; a real matcher swaps in at the seam), NOT for graph storage/query engine choice.

0
installs
▌
Parallel Reconcile Merge · anthonyalcaraz bundle
Controlled-parallelism window for a tree pipeline (Ch5 Tree Pipeline + "The architecture of controlled parallelism" + state reducers, Examples 5-7/5-8/5-16). Dispatches independent branches that read different data and write to separate channels, isolates errors per-branch so one branch's failure neither cascades nor corrupts shared state, then reconciles the survivors with a reducer-style deterministic merge and decides completion as all-or-nothing or partial-coverage. Surfaces the union of every branch's red flags — a failed branch never silently drops a flag. Use when a planning node has verified true independence between branches (fraud / provider / pricing verification; parallel hypothesis tests). NOT for branches that share mutable state or make joint decisions (that is uncoordinated parallelism, the failure mode), NOT for strictly sequential dependent steps, NOT as a thread pool (this is the isolation+merge contract; the concurrency mechanism is a production swap).

0
installs
▌
Semantic Backprop Attributor · anthonyalcaraz bundle
Ch7 self-evolution primitive: attribute a failure to the node that actually caused it, then generate NEIGHBOR-AWARE textual feedback that flows backward through the execution graph from the point of failure. Adapts TextGrad's textual-gradient insight (feedback as a gradient signal) plus the chain rule: when generating feedback for a node based on what its successor needed, the feedback includes the outputs of ALL OTHER predecessors of that successor. That neighbor context is what prevents incorrect credit assignment. Use AFTER a diagnostic report has localized a failing node and you need coherent, cross-graph feedback before an intervention. NOT for single-node pipelines with no neighbors (there is no action-at-a-distance to prevent), NOT the intervention itself (this decides where and what should change, SEAL/TPT/prompt refinement make the change stick).

0
installs
▌
Xskill Self Improving Object · anthonyalcaraz bundle
Turn execution traces into knowledge that improves without retraining. Two Ch7 primitives compose: XSkill dual-stream extraction distills EXPERIENCES (action-level: what worked or failed for one tool call) and SKILLS (task-level: a multistep pattern that solves a category of task) from the execution graph. Cognee then treats each skill as a graph OBJECT that observes its own executions, computes its success rate, and rewrites itself via amendify() when it degrades. Routing selects skills by demonstrated success on the task pattern, not by description similarity. Use to give an agent memory of past failures (experiences alone cut tool errors 29.9% to 16.3%) and skills that track a changing environment. NOT for a static agent that never re-runs similar tasks (no traces to learn from), NOT for the raw execution graph itself (use the execution-graph skill, which is the substrate this consumes).

0
installs
▌
Irreversible Action Gate · anthonyalcaraz bundle
Gate agent tool calls by reversibility BEFORE execution: classify each action REVERSIBLE / SEMI_REVERSIBLE / IRREVERSIBLE from its declared properties (side-effect scope, idempotency, destructiveness, compensating action), prescribe the matching delivery contract (idempotency key, retry policy, dry-run-first, human approval, compensation registration), check deterministic preconditions against graph facts, and analyze multi-step plans as sagas with an explicit point of no return. Use whenever an agent executes tools with side effects — anything beyond pure reads. NOT for read-only pipelines (nothing to gate), NOT a transaction manager (it prescribes the contract; your executor enforces it), NOT a substitute for the Ch6 information-flow or trust gates (those govern data and tool quality; this governs consequence).

0
installs
▌
Investigation Dag Planner · anthonyalcaraz bundle
Dynamic-DAG construction for a planning node (Ch5 Example 5-15 + the DevOps "Constructing the Investigation DAG" section). Given hypotheses/tasks with dependency constraints, compute a topological-level decomposition: each level is a phase of tasks that can run concurrently, ordered within-phase by priority. The estimated duration of a parallel phase is the MAX over its concurrent tests, and execution runs phase-by-phase with early termination once a hypothesis is confirmed. Detects dependency cycles as malformed plans. Use when a planning node must decide which work is parallel-safe and in what order — incident-investigation hypothesis testing, multi-track research, multi-party claim processing. NOT for purely linear pipelines (one task per level — annotation overhead exceeds benefit), NOT for runtime fault-isolation (that is event-driven orchestration), NOT for picking a model or pipeline shape (that is architecture selection).

0
installs
▌
Evolution Taxonomy Classifier · anthonyalcaraz bundle
Locate a proposed self-evolution in the four-dimensional design space Gao et al. (2025) formalize: WHAT evolves (model / context / tool / architecture), WHEN it fires (intra-test-time within one request / inter-test-time between requests), HOW the agent learns (reward / imitation / population), and WHERE it applies (general-purpose / domain-specialized). Each axis value carries the graph-dependency rationale the chapter gives, and a diagnosed failure type routes to its primary evolution axis, timing, and mechanism (Table 7-1). Use AFTER the diagnostic report exists and BEFORE you pull an evolution lever, so you fix the right target instead of wasting compute or introducing regressions. NOT for producing the diagnosis itself (that is the execution-graph plus cognitive-fault-isolator upstream), NOT for executing the evolution (this classifies and routes; it does not fine-tune, rerank, or restructure).

0
installs
▌
Graduated Validation Protocol · anthonyalcaraz bundle
The Ch7 safety envelope for a self-evolving agent: the RPO spine (Recursion, Provenance, Optimization) plus the Graduated Validation Protocol that gates what reaches production. Assigns every candidate change a risk tier and applies the matching scrutiny: Tier 1 canary (1% traffic, automatic rollback), Tier 2 staging gauntlet (multi-objective utility, passes only net-positive with no safety regression), Tier 3 airlock (sandboxed risk/reward report escalated for human approve/reject/modify). Also the entropy-collapse guard (Kepler dual-store): daily garbage collection of agent-generated Learnings once promoted, contradicted, or idle past a 30-day TTL. Use to gate a continuous self-evolution loop before candidate changes reach users. NOT for a one-off manual deploy (a single approval gate is enough), NOT for the diagnosis / attribution / intervention steps that produce the candidate (this validates the candidate, it does not generate it).

0
installs
▌
Draft Tool Trust Verifier · anthonyalcaraz bundle
Establish trust in a tool by verification, not by its self-description. Flags marketing-gamed tool descriptions ("industry-leading", "trusted by Fortune 500"), requires structured testable capabilities instead of free-text claims, tracks a performance-based trust score (neutral start, successes up, failures and slow calls down), and runs the DRAFT loop — gather boundary-probing experience, learn the gap between documentation and reality, rewrite an AI-optimized spec — until the doc converges with actual behavior. Use when a tool registry ingests third-party or provider-authored descriptions that may be optimized for discovery over accuracy. NOT for tools you authored and fully control, NOT a functional test framework (it discovers doc-vs-reality gaps, it does not assert business correctness), NOT a security scanner.

0
installs
▌
Graph Model Selector · anthonyalcaraz bundle
Select a graph data model — labeled property graph (LPG) vs RDF vs hypergraph — by scoring REASONING REQUIREMENTS against five implementation features (formal reasoning, n-ary relations, performance, tool ecosystem, constraint expressiveness), per Ch3 "Evaluating Graph Models". Also models the n-ary -> hyperedge representation (Example 3-1: a prescription connecting doctor + patient + medication + dosage + date + condition as ONE hyperedge vs the 1-intermediate-node + N-edge reification an LPG/RDF forces). The chapter's rule: start from "what reasoning must my agents do?", not from the data. Use when choosing a graph backend for an agentic system, justifying a build-vs-buy or model choice, or deciding whether an n-ary fact needs a hyperedge. NOT for picking a specific vendor product (this picks the model class, not Neo4j-vs-Neptune), NOT for non-graph storage decisions, NOT when the org already mandates a model (just adopt it).

0
installs
▌
MCP Gateway Two Meta Tools · anthonyalcaraz bundle
Build a gateway that exposes any-size tool registry through just two meta-tools: search(query) and execute(tool_name, **params). Tool descriptions stay outside the prompt entirely — the agent's prompt cost is constant regardless of registry size. Use when you need per-tenant tool segmentation, per-agent access policies, or are scaling to hundreds-of-tools where even top-k injection (rag-mcp- tool-selection) bloats prompts. NOT for cases under 30 tools where RAG-MCP top-K injection is simpler. NOT a security layer on its own — bring an IAM/RBAC source-of-truth for the access_filter.

0
installs
▌
Homoiconic Meta Schema · anthonyalcaraz bundle
Homoiconic knowledge representation (Ch3) — code and data share the same representation so an agent can inspect and modify its own knowledge structures with the same machinery it uses for regular data. Two constructs: (1) meta- knowledge structures (Example 3-6) — validate an entity-type against the metaschema AND a data instance against its entity-type using the SAME validator at both levels; (2) executable knowledge patterns (Example 3-7) — parse, validate, and evaluate Rule entities with a tiered WHEN/THEN/ELSE action against facts. Use when building self-evolving agents that reason about / modify their own schema, when storing business rules as queryable graph data instead of hidden application code, or when validating agent-proposed schema extensions. NOT for static schemas that never change (a plain class/struct is simpler), NOT for executing arbitrary code (this evaluates a constrained tiered-rule grammar, not a general interpreter), NOT for the schema PATTERN choice (use schema-pattern-selector).

0
installs
▌
Federated Context Governance · anthonyalcaraz bundle
Govern agent-configuration drift once tool orchestration scales from one developer to a team. Detects where independently-authored context configs (CLAUDE.md-style settings + installed skills) diverge, classifies the fragmentation stage, enforces a FEDERATED org base whose nonnegotiable settings (security, architectural, compliance) every team must inherit unchanged while owning their negotiable extensions, and routes a governance need to the right architectural layer (Config-as-Code / Shared Knowledge Layer / Governance Control Plane). Use when multiple developers or teams configure agents independently and their outputs are diverging. NOT for a single developer's setup (there is no drift), NOT a code linter (it governs agent CONTEXT, not source code), NOT a secrets manager (it flags a policy key, it does not store secrets).

0
installs
▌
Schema Pattern Selector · anthonyalcaraz bundle
Select and validate the four agent schema design patterns from Ch3 — Event-Centric (temporal reasoning), Contextual-Boundary (scope/validity boundaries), Multi-Perspective (contradictory viewpoints with attribution and confidence), and Capability-Model (agent self-awareness of authority limits). Given a free-text description of a knowledge shape, it scores which pattern(s) fit and flags composition when several apply; given a pattern instance, it validates the required relationships/fields without which the pattern is broken. Use when modeling knowledge for agent reasoning, when deciding how to structure events / contexts / conflicting data / agent authority, or when reviewing a schema for the missing temporal- or attribution-relationship that breaks the pattern. NOT for choosing the graph model class (use graph-model-selector), NOT for runtime authorization enforcement (use capability-authorization-gate), NOT for entity-centric data with no temporal/perspectival/scope dimension (a plain node is fine).

0
installs
▌
Information Flow Control Gate · anthonyalcaraz bundle
A deterministic security-policy layer for chained tools. Does two things: (1) discovers tool dependency chains by matching one tool's output TYPE to another tool's input TYPE (the NESTFUL failure mode where LLMs miss that COVID stats need a country code first); (2) tracks data taint with FIDES-style TRUSTED/UNTRUSTED labels that propagate through operations, so a sensitive action is blocked when its data is tainted, with opaque-variable references keeping raw untrusted content out of the LLM's reasoning. Use when tools chain and untrusted data can reach a sensitive action. NOT a replacement for authentication (that verifies the caller; this governs the data), NOT for single-tool calls with no chaining, NOT a general policy engine (it enforces the two IFC mechanisms the chapter names, not arbitrary rules).

0
installs
▌
Pipeline Architecture Selector · anthonyalcaraz bundle
Treat pipeline-architecture choice as a routing decision inside a meta-pipeline (Ch5 Hybrid Architectures, Examples 5-10/5-11). A single analysis pass over task characteristics — complexity and answer-uncertainty — selects sequential (simple + certain), tree (high uncertainty, explore hypotheses), or loop (iterative refinement); a resource-aware wrapper then degrades gracefully when memory or time budgets bite (tree -> sequential fallback, loop -> single-pass best effort). Use when the same agent must handle tasks of variable complexity and committing to one architecture wastes resources on simple tasks or under-serves hard ones. NOT for systems with a single fixed task shape (just hard-code the pipeline), NOT for choosing between models (that is model selection), NOT for sub-50-task/day systems where event-driven scaling is the real question.

0
installs
▌
Constraint Guided Plan Validator · anthonyalcaraz bundle
Validate a generated plan against extracted domain constraints AND the agent's capability model before execution (Ch5 Constraint-guided planning, Example 5-14, plus the DevOps hypothesis-formation capability filter). Scores the plan 0..1, returns structured per-step feedback so a planning node can refine when the score falls below threshold, and filters steps the agent is not authorized to perform (e.g. a step needing write access when the agent holds read-only monitoring). Forbidden-action and capability violations are HARD — a plan the agent cannot legally execute does not pass regardless of score. Use in regulated or capability-bounded environments where plans must respect business rules and operational authority before any action runs. NOT for free-form creative tasks with no constraints, NOT for validating execution results after the fact (this gates the plan, not the outcome), NOT as the constraint extractor itself (it consumes extracted constraints).

0
installs
▌
Hierarchical Orchestration Router · anthonyalcaraz bundle
Expose ONE orchestrator to the agent instead of thousands of tools. Classifies a query into a department domain (Sales / Finance / Operations); routes to that domain's orchestrator when confidence exceeds 0.8, else orchestrates cross-domain. Within a domain, clusters tools by FUNCTION so an overloaded or failing tool fails over to a functionally-equivalent alternative from the same cluster (a Search Toolkit, a Metrics Toolkit), adapting parameters. Use when tool and agent counts have grown past a flat registry and you need routing, fault isolation, and no single point of failure. NOT for a single-domain system with a handful of tools (routing overhead buys nothing), NOT a replacement for tool retrieval within a domain (compose with rag-mcp-tool-selection there), NOT a security boundary (per-domain access control is a separate layer).

0
installs
▌
Capability Authorization Gate · anthonyalcaraz bundle
Runtime authorization gate built on the Ch3 Capability Model Pattern — a self-aware agent represents its own capabilities, required resources/grants, authorization level, and quantitative limits as queryable structure, then checks at PLANNING time whether it may perform an action BEFORE attempting it. Returns allow, escalate (the agent itself cannot but a higher authority could — route appropriately), or deny (the capability is undeclared). The canonical case: a support agent with a $500 refund limit escalates a $600 request. Use when an agent must decide can-I-do-this before acting, when modeling agent operational boundaries, or when building the queryable authority layer that gates tool use (Ch6). NOT for human RBAC/IAM policy enforcement (use the platform's IAM), NOT for validating that a capability NODE is well-formed (use schema-pattern-selector's capability_model validation), NOT a replacement for actual credential checks at the API boundary (this is the planning-time gate).

0
installs
▌
Structured Output Contract Designer · anthonyalcaraz bundle
Design the OUTPUT CONTRACT for a graph-agent node's seam, per Ch5 "Structured Generation: The Keystone of Reliable Communication" (Outlines). Most graph-agent failures are internode COMMUNICATION breakdowns, not bad reasoning — a node that emits free text is unreliable exactly where its output feeds the next node or a graph write. The designer picks an enforcement level (FREE_TEXT / JSON_SCHEMA / GRAMMAR_CONSTRAINED), emits a minimal contract for common DevOps-investigation node types, and validates a payload against that contract deterministically — the primitive that makes a seam verifiable. Use when wiring a node's output into another node, a graph write, or a tool call and free text would make the seam fragile. NOT for choosing WHICH pipeline shape to run (that is pipeline selection), NOT for terminal human-facing prose with no downstream parser, NOT for picking a model or a graph model class.

0
installs
▌
Kg Extraction Approach Selector · anthonyalcaraz bundle
Select a knowledge-graph EXTRACTION approach for a given source — structured database integration vs LLM-based triple extraction vs iText2KG (incremental) vs RAKG (document-level) — by scoring a SOURCE PROFILE against five features (handles unstructured text, incremental-friendly, document-level context, determinism, setup cost), per Ch3 "Extraction Approaches for Heterogeneous Sources". A structured source hard-routes to schema materialization; the `incremental-cost` helper makes the iText2KG win concrete (re-process only new documents, not the entire corpus). Use when picking how to ingest a source into an agent's knowledge graph. NOT for choosing the graph MODEL class (use graph-model-selector), NOT for vendor/product selection, NOT for temporal/bitemporal modeling (that is the ATOM discussion, out of scope here), NOT when the ingestion pipeline is already mandated.

0
installs
▌
Knowledge Organization Classifier · anthonyalcaraz bundle
Classify an organizational vocabulary onto the Ch3 knowledge-organization spectrum — pick list -> taxonomy -> thesaurus -> ontology — by the structural features the spec actually exhibits, walking bottom-up so a partial ontology does NOT over-claim. Also validates that something claiming to be an ontology carries the five core components the chapter names (classes, subclasses, individuals, axioms, relationships) with no dangling parent/class references, and recommends the next-tier upgrade with the concrete feature to add. Use when auditing an existing taxonomy/vocabulary before integrating it into an agent knowledge graph, when deciding whether you need a full ontology or a simpler structure, or when validating an AI-assisted ontology draft. NOT for building the ontology content itself (that is domain modeling), NOT for the SKOS cross-vocabulary mapping step (exactMatch/broader/related — a different primitive), NOT for entity resolution (use three-graph-router's linkage gate).

0
installs
▌
Entity Resolution Strategy Selector · anthonyalcaraz bundle
Choose HOW to decide when two records are the same real-world entity — EVIDENCE-BASED resolution (deterministic feature-by-feature scoring with explainable evidence and culturally-robust rules) vs GENERALIZATION-BASED AI (LLM statistical similarity, nondeterministic, post-hoc rationalization) — per Ch3 "Entity Resolution: The Foundation of Agent Knowledge". Scores a six-factor requirement profile and picks evidence-based, generalization-AI, or a hybrid; ships a deterministic matcher that scores name/address/phone similarity into an explainable confidence, classifies the resulting graph edge, and flags the edge cases naive matching misses. Use when standing up entity resolution for an agent knowledge graph, justifying an evidence-vs-LLM choice for identity/compliance/fraud work, or auditing a proposed merge. NOT for the extraction stage that produces the records (that is upstream KG construction), NOT for picking a specific ER product, NOT for arity-2 relationship modeling (use graph-model-selector).

0
installs

51 published skills