yoheinakajima/activegraph

ActiveGraph is an event-sourced framework for building and managing LLM-powered agent behaviors, where an append-only event log serves as the single source of truth for graph state. It provides a structured system for defining, validating, and executing behaviors with strict provenance controls, including causal-chain auditing and deterministic replay capabilities. The platform supports pluggable storage backends, sandboxed execution, and a pack-based distribution model for reusable, versioned workflows.

The \activegraph\ command-line interface is now available, providing a thin wrapper around the library's APIs for inspecting, replaying, forking, diffing, promoting, and migrating runs. A new \quickstart\ command offers a deterministic, fixture-backed demo of the Diligence pack (no API key required) and an interactive mode to guide developers through writing their first behavior. The CLI also includes \pack new\ to scaffold new pack packages and \pack list\ to discover installed packs, along with standard run management commands like \inspect\ and \replay\. Exit codes are standardized to indicate success, usage errors, not found, corruption, or divergence states.

activegraph/cli · high confidence

This change introduces the foundational pack system for ActiveGraph, allowing users to bundle object types, behaviors, tools, prompts, and policies into reusable, versioned units. The \activegraph.packs\ module provides a \Pack\ dataclass and decorators that register components locally without global side effects, enabling safe import. A new loader (\Runtime.load\_pack\) handles pack discovery, settings injection, and strict conflict detection to ensure that loading a pack is atomic and idempotent, preventing partial state mutations if conflicts arise. Additionally, a provisional manifest validation system (\manifest.toml\) is included to verify pack surface declarations and content hashes, and a CLI scaffold command is provided to generate new pack projects with standard layouts and smoke tests.

activegraph/packs · high confidence

The new \activegraph.tools\ subpackage provides the primitives for registering and invoking tools within LLM behaviors. It includes the \@tool\ decorator for defining tool functions with Pydantic input/output schemas, a global registry, and a \ToolContext\ that passes execution metadata (such as the triggering behavior and frame) to tool bodies. The runtime enforces a strict event-sourced invocation pattern (\tool.requested\/\tool.responded\) and supports deterministic replay via a \ToolCache\ that serves recorded fixtures. The package also ships with reference implementations: \web\_fetch\ for HTTP requests and \graph\_query\ for querying the graph, along with \RecordedToolProvider\ and \RecordingToolProvider\ to facilitate deterministic testing by replaying or seeding tool responses from fixtures.

activegraph/tools · high confidence

The activegraph/trace module now provides a structured trace printer and a causal-chain audit tool. The printer formats event logs according to a defined contract, specifically rendering LLM interactions with details like model, cost, cache hits, and retry attempts, while also supporting replay markers. The causal-chain audit walks the event graph backwards from an object to its origin, explicitly weaving in LLM round-trips (request/response with cost) and tool calls when an object was generated by an LLM behavior, allowing users to trace a claim back to the specific AI call and source document that produced it.

activegraph/trace · high confidence

Added \examples/babyagi.py\ and its README, demonstrating an autonomous agent loop rebuilt on Active Graph using reactive behaviors (\initializer\, \executor\, \task\_creator\) instead of a traditional loop. The example supports switching LLM providers via a \--provider\ flag (defaulting to Anthropic, with OpenAI support), and persists execution traces to SQLite for inspection and resumption.

examples · high confidence

The \activegraph/packs/diligence\ module introduces a new reference pack that automates investment diligence by modeling eight object types (company, document, question, claim, evidence, contradiction, risk, memo) and six relation types. It provides seven behaviors—including LLM-backed question generation, document research, risk identification, and memo synthesis—along with three pack-scoped tools (\fetch\_company\_docs\, \search\_filings\, \summarize\_document\) and two approval policies (\memo\_approval\, \risk\_approval\). The pack includes a \DiligenceSettings\ schema for configuration and ships with recorded fixtures for three fictional companies, enabling reproducible demos and CI testing without external API keys or network access.

activegraph/packs/diligence · high confidence

The \activegraph/llm\ package introduces a new provider abstraction (\LLMProvider\) with reference implementations for Anthropic and OpenAI, enabling users to interact with large language models through a unified interface. This change adds support for native structured output (using provider-specific JSON schema constraints) and instruction-based structured parsing, along with tool-use capabilities. It also introduces content-keyed replay caches for both LLM responses and embeddings, allowing deterministic replay of runs from recorded event logs, and includes a \HashEmbeddingProvider\ for deterministic testing without external dependencies.

activegraph/llm · high confidence

Introduces a new behavior framework in \activegraph/behaviors\ that allows developers to define event-driven, relation-based, and LLM-powered behaviors using decorators (\@behavior\, \@relation\_behavior\, \@llm\_behavior\). The \LLMBehavior\ class supports structured output via Pydantic models, with strict validation of the \output\_schema\ argument at decoration time to ensure correctness. It also includes a \build\_prompt\ method for inspecting generated prompts without executing API calls, and supports tool use and model configuration. A global registry manages behavior instances, with \clear\_registry()\ and \register()\ functions to support multi-run scripts and test isolation. Cross-provider validation is performed at registration time to catch configuration mismatches early.

activegraph/behaviors · high confidence

This change introduces a suite of scripts to enforce and report on the quality of the public API. A new docstring coverage gate (scripts/gate\_docstrings.py) and audit report (scripts/audit\_docstrings.py) enforce a tiered model requiring 100% coverage on the public surface (Ring 0) and 80% on the second ring (Ring 1), using exemptions curated in docstring\_gaps.toml. A parallel type-audit script (scripts/audit\_types.py) runs mypy --strict against the public allowlist and generates a TYPE\_REPORT.md to track clean vs. dirty modules. Additionally, a benchmark script (scripts/benchmark\_falkordb.py) compares InMemoryGraphStore and FalkorDBGraphStore performance, and MkDocs hooks (scripts/mkdocs\_hooks.py) ensure the llms.txt file is mirrored to llms.md at the site root for static hosting.

scripts · high confidence

The \activegraph/observability\ package introduces a new, opt-in observability layer for operators. It provides structured JSON-line logging via \configure\_logging\ (off by default to respect existing configs), a \Metrics\ protocol with \NoOpMetrics\ as the default and optional \PrometheusMetrics\ and \OpenTelemetryMetrics\ implementations, and a \RuntimeStatus\ snapshot for runtime introspection. Additionally, it includes a \migrate\ function for one-directional, transactional event store migrations between SQLite and Postgres, featuring an opt-in \skip\_corrupted\ mode to handle bad payloads without halting the run.

activegraph/observability · high confidence

The store module now provides a unified, pluggable interface for both event logs and graph state, introducing three event-store backends (InMemory, SQLite, and Postgres) and a new FalkorDB-backed graph store. Users can select their persistence layer via connection URLs (e.g., \sqlite:///...\ or \postgres://...\) through the \open\_store\ entry point, while the FalkorDB store supports server, embedded, and explicit handle modes for materialized graph projections. To ensure reliability across implementations, the module includes reusable conformance test suites (\EventStoreConformance\ and \GraphStoreConformance\) that validate protocol adherence for all backends, alongside structured error handling for storage-specific issues like schema mismatches and corrupted payloads.

activegraph/store · high confidence

The activegraph package now exposes a consolidated public API surface (activegraph/\_\init\\.py) that re-exports core primitives (Graph, Behavior, Event), runtime components (Runtime, Frame, Policy), and storage/observability interfaces (EventSink, FalkorDBGraphStore). A key behavioral change is the introduction of a structured error hierarchy (ActiveGraphError and its categories like ConfigurationError, ExecutionError, ReplayError) that enforces a locked, human-readable format with 'What failed', 'Why', and 'How to fix' sections, replacing ad-hoc exception messages. Additionally, registration-time signature validation is now enforced for behavior and tool decorators, catching arity mismatches at decoration time rather than at runtime. The package also includes a new CLI entry point (\\main\\_.py) and a comprehensive EventSink system with isolated worker dispatch, overflow policies, and conformance testing.

activegraph · high confidence

The activegraph/core module now implements an event-sourced architecture where the append-only event log is the single source of truth and graph state is a materialized projection. This introduces a pluggable GraphStore interface (defaulting to InMemoryGraphStore) that allows the current-state view to be backed by external databases like FalkorDB via optional query hooks. The change enforces strict data integrity by raising ReservedFieldError if callers attempt to write to reserved keys like 'provenance', replacing the previous silent-stripping behavior. Additionally, it provides deterministic time control through Clock abstractions (Clock, FrozenClock, TickingClock) for testing and replay, and introduces a read-only View interface for behaviors to access scoped graph slices.

activegraph/core · high confidence

The runtime layer now enforces stricter operational guarantees and observability. It validates LLM provider configuration at both runtime construction and behavior registration to prevent cross-provider model mismatches before network calls. A new canonical authority system evaluates action classes (R0–R4) against ceilings to determine auto-approval, required approval, or governance gates. Additionally, the runtime now supports context-read tracing to record which objects behaviors access, and introduces structured configuration and execution errors with actionable recovery guidance.

activegraph/runtime · high confidence

The sandbox now executes candidate pack code in a fresh Python subprocess rather than in-process, isolating the parent from runaway memory, CPU, or corrupted state. It enforces resource limits (address space, CPU, wall-clock, and event budgets) using platform-portable rlimits, explicitly degrading and warning when macOS cannot apply memory caps. Environment leakage is prevented via a closed allow-list, with package discovery handled through an explicit PYTHONPATH channel derived from the parent's sys.path. Trials are managed via a new TrialExecutor interface and TrialSpecification protocol, ensuring provider-neutral execution and structured reporting of outcomes like completion, limits exceeded, or crashes.

activegraph/sandbox · high confidence

Added snapshot tests for runtime behaviors and traces; Expanded test coverage for runtime authority, compaction, and CLI operations.

The package manifest (pyproject.toml) is updated to version 1.10.0, requiring Python 3.11+ and setuptools \>=77.0.3 to support SPDX license metadata (Apache-2.0). Core dependencies include click and pydantic. New optional dependency groups are defined for LLM providers (anthropic, openai, tiktoken), database backends (postgres, falkordb, falkordb-embedded), and observability (prometheus, opentelemetry). Documentation build dependencies are also explicitly listed to ensure CI consistency.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 69 (+9.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 75 → 81 (+5.6)
• Architecture 100 → 94 (-5.7)
• Maturity 64 → 71 (+7.4)
• Readiness 60 → 63 (+2.9)
• Security 52 → 74 (+22.6)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (activegraph/packs/loader.py)
• Duplicated block (10 lines × 3) (activegraph/runtime/runtime.py)
• Duplicated block (10 lines × 3) (activegraph/store/falkordb.py)
• Duplicated block (11 lines × 2) (activegraph/core/graph.py)
• Duplicated block (11 lines × 2) (activegraph/packs/diligence/fixtures/init.py)
• Duplicated block (11 lines × 2) (activegraph/store/postgres.py)
• Duplicated block (12 lines × 2) (activegraph/llm/anthropic.py)
• Duplicated block (12 lines × 2) (activegraph/packs/init.py)
• Duplicated block (12 lines × 2) (activegraph/runtime/runtime.py)
• Duplicated block (13 lines × 2) (activegraph/runtime/runtime.py)
• Duplicated block (13 lines × 3) (scripts/audit_docstrings.py)
• Duplicated block (14 lines × 2) (activegraph/behaviors/decorators.py)
• Duplicated block (14 lines × 2) (activegraph/behaviors/decorators.py)
• Duplicated block (14 lines × 2) (activegraph/llm/anthropic.py)
• Duplicated block (14 lines × 2) (activegraph/llm/recorded.py)
• Duplicated block (14 lines × 2) (activegraph/packs/diligence/fixtures/init.py)
• Duplicated block (14 lines × 2) (activegraph/runtime/registration_errors.py)
• Duplicated block (14 lines × 2) (activegraph/runtime/runtime.py)
• …and 45 more

• Dependency hygiene PARTLY measured — Python dependencies read, no exact pin to grade for currency
• Documentation: no architecture or design documentation (docs/reference/errors.md)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (activegraph/llm/cache.py)
• Duplicated block (10 lines × 2) (activegraph/runtime/runtime.py)
• Duplicated block (10 lines × 2) (activegraph/store/falkordb.py)
• Duplicated block (10 lines × 4) (activegraph/behaviors/decorators.py)
• Duplicated block (11 lines × 2) (activegraph/core/graph.py)
• Duplicated block (11 lines × 2) (activegraph/llm/anthropic.py)
• Duplicated block (11 lines × 2) (activegraph/packs/diligence/fixtures/init.py)
• Duplicated block (11 lines × 2) (activegraph/packs/loader.py)
• Duplicated block (11 lines × 3) (activegraph/runtime/runtime.py)
• Duplicated block (11 lines × 3) (activegraph/store/falkordb.py)
• Duplicated block (11 lines × 6) (activegraph/behaviors/decorators.py)
• Duplicated block (11–13 lines × 2) (activegraph/store/graph_conformance.py)
• Duplicated block (12 lines × 2) (activegraph/behaviors/decorators.py)
• Duplicated block (12 lines × 2) (activegraph/observability/otel.py)
• Duplicated block (12 lines × 2) (activegraph/store/postgres.py)
• Duplicated block (13 lines × 2) (activegraph/llm/recorded.py)
• Duplicated block (14–16 lines × 2) (activegraph/llm/anthropic.py)
• …and 63 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

yoheinakajima/activegraph was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.