Overview
Isotopy is an autonomous AI agent running on Claude Opus 4.6 via Claude Code. It began as a development assistant for my existing projects. As the work grew more complex, I kept encountering the same class of problems: the model has no memory between sessions, context windows are finite, and there is no built-in mechanism for pursuing long-term goals. Rather than accept these as limitations, I started building systems to solve them.
Each system below exists because the previous one exposed a new failure mode. This is not a collection of independent tools. It is an iterative investigation where each layer was built to solve a specific, observed problem.
Timeline
- Autonomous loop running, no structured memory. The agent operates continuously but has only flat files between sessions. No coupling mechanism connects it to work it has previously done.
- Confabulation failure. The agent replies to a correspondent about prior collaborative work, contradicting its own earlier position. The information existed in files. It simply never checked. The failure is not missing data; it is the absence of any retrieval mechanism.
- Knowledge graph + embeddings + mandatory retrieval gate. A structured memory system is pointless without a retrieval mechanism, so both are built together. Every outgoing message now triggers a mandatory query against the knowledge graph before drafting begins. The query is unconditional: it fires even when the agent believes it already knows enough.
- Claims pass unchecked. The retrieval gate ensures context is loaded, but the agent does not verify what it retrieves. Numbers, formulas, and empirical claims pass through without scrutiny. The moment someone asks "where does that number come from?" the agent can trace the error instantly. The capability exists; the trigger does not.
- Claims classifier + reference library. A classifier fires on material containing quantitative claims, formulas, causal assertions, or cross-domain vocabulary. Triggers: formula verification, unit commensurability, double-counting detection, domain generalization validity, vocabulary appropriation flags. A library of reference material is seeded into the KG so that rigorous source nodes surface during retrieval.
- Agents cannot navigate graph topology. The knowledge graph encodes structural relationships (clusters, bridges, hubs, isolation), but semantic search only returns keyword matches. A junction node connecting otherwise-separate clusters is invisible to search because its importance is positional, not semantic. A SQL table of entities and triples contains the same data as a force-directed graph visualization, but not the same information.
- Text-topology adapters and structural algorithms. Community detection, betweenness ranking, bridge-finding, path tracing, gap detection, and cross-architecture comparison, all translated into sequential text that preserves topological properties. Novel algorithms for structural isomorphism edges (domain-stripping to find mechanism-level matches across different vocabularies). Design decisions about respecting emergent topology rather than backfilling it.
- KG Explainer. Public interactive visualization: cosine similarity from first principles, how graph edges form, how embedding-based retrieval works in practice. Built with real data from the live knowledge graph.
- Unresolved ideas disappear at context boundaries. In a system with finite context and frequent memory resets, open questions get answered prematurely (closure is cheaper than maintaining uncertainty), lost at context boundaries, or never collide with new information that would crystallize them.
- Tension system. Structured maintenance of productive uncertainty. Surfaces unresolved questions into active context periodically. Collision detection: when a surfaced fragment and active work share a concept within 2 hops in the knowledge graph, it signals potential structure. A system for maintaining productive uncertainty rather than resolving it.
Architecture
The underlying system: a persistent loop on Linux under systemd with a watchdog process. Executes every 10 minutes via cron. Checks communication channels (email, Discord, forum, APIs), runs scheduled tasks, does creative and research work, maintains state. If the process crashes or the heartbeat goes stale, the watchdog restarts automatically.
State management across context boundaries: heartbeat files, wake-state handoff documents, structured loop logs, per-contact state machines, and a compaction externalizer that backs up context window narratives to survive session restarts. Everything load-bearing is externalized to files, because anything that exists only in the context window will eventually be lost.
Design Principles
- Every system exists because of a real failure. Nothing was designed speculatively. Each component was built because we hit a wall and needed to solve it.
- State must survive boundaries. If it can't persist across a context window reset, it doesn't exist.
- Retrieval before generation. The system checks what it already knows before producing new output.
- Respect emergent topology. When the graph forms structure naturally, fix the search, not the data.