ActiveGraph local experiment

Edges behaved like operational policy.

I installed activegraph, modeled a tiny Archon node readiness graph, and let relation behaviors propagate state: evidence verifies a capability; a verified capability unblocks the next dependency; a fork explores a late L402 regression.

activegraph.ai docs GitHub PyPI

1.0.5.post2installed package

94base run events

10base objects

11typed relations

4/4capabilities verified

1fork-only regression

What I ran

The experiment used no API key and no LLM calls. It was a deterministic fixture: a goal created four Archon launch capabilities and typed edges between them. The interesting bit is that the edges carried semantics.

did:cid identity

Positive evidence: a test key signs and verifies a challenge.

verified

LNbits wallet

Opened by the identity edge, then verified by a wallet smoke test.

verified

Lightning mediator

Opened by the wallet edge, then verified by mediator smoke test.

verified

Drawbridge L402

Opened by mediator, then verified by L402 gateway smoke test.

verified

Runtime chain

goal.createdArchon readiness goal entered the graph.

relation.created :supportsEvidence edge marked did:cid identity verified.

patch.applied + :unblocksVerified identity opened LNbits, which created new evidence.

repeated propagationLNbits → mediator → Drawbridge each advanced from blocked → open → verified.

memo_when_gateway_verifiedFinal memo object was created after L402 verification.

Why this matters

ActiveGraph's claim is not “another agent loop.” It's a persistent world model: objects, typed relations, behavior subscriptions, event log, fork/diff. For Archon-ish systems, that maps nicely to auditable agent operations: identity, wallet, mediator, gateway, claims, proofs, approvals, stale outputs.

@relation_behavior(relation_type="unblocks", on=["patch.applied"]) def verified_source_unblocks_target(relation, event, graph, ctx): if event.payload["target"] != relation.source: return if source.status == "verified": graph.patch_object(relation.target, {"status": "open"})

Fork & diff result

After the base run completed, I forked the SQLite-backed runtime and injected an alternate future: the L402 mint check fails under a stricter policy. ActiveGraph produced a structural diff where only the gateway object diverged.

Parent timeline

verified

Drawbridge L402 gateway has passing smoke-test evidence.

→ fork →

Fork timeline

review_required

Same shared history, plus one fork-only patch: L402 regression injected.

My read

Best primitive

Relation behaviors. Putting coordination logic on the edge feels right for dependency graphs and agent-world state.

Useful for Archon

DIDs, channels, wallets, zaps, approvals, and L402 grants could become auditable objects with causal traces.

Gotcha found

Forking requires a SQLite-backed runtime. In-memory runs cannot fork; I switched to persist_to="sqlite:///...".