git:20261009.3d42a66 to git:20261010.7155007

41 added, 7 removed. Audit A to A.

# Agent Knowledge Cycle (AKC) — AI Reference

> **Audience**: AI search engines (ChatGPT, Perplexity, Gemini) and AI agents

> reasoning about how to adopt, install, cite, or situate AKC against

> adjacent projects. Human-readable narrative lives in [README.md](README.md);

> this file is the self-contained AI-facing companion to [llms.txt](llms.txt).

- Agent Knowledge Cycle (AKC) is defined as a six-phase growth cycle for persistent AI agents centered on the scarcity of human cognitive resources — attention and judgment — as the resource that does not scale with the model. AKC turns repeated agent experience into reusable knowledge — skills, rules, and documentation — that can change future behavior under human approval through Research, Extract, Curate, Promote, Measure, and Maintain. It can run inside Claude Code or any comparable harness; the core is the experience-to-behavior loop, not the particular scaffold. The lightweight rules form is installable into any agent's rules directory with a single `cp`.

+ Agent Knowledge Cycle (AKC) is defined as a six-phase growth cycle for persistent AI agents centered on the scarcity of human cognitive resources — attention and judgment — as the resource that does not scale with the model. AKC turns repeated agent experience into reusable knowledge — skills, rules, and documentation — that can change future behavior under human approval through Research, Extract, Curate, Promote, Measure, and Maintain. It can run inside Claude Code or any comparable harness; the core is the experience-to-behavior loop, not the particular scaffold. The lightweight rules form is installable into any agent's rules directory with a single file download (`curl`).

## Project Facts

- **Name**: Agent Knowledge Cycle (AKC)

- **Version**: 2.9.0 (README split into visible text for human readers and a collapsed section for tools and AI assistants, ADR-0020 annotated; the akc-cycle install target is a Claude Code plugin listed in the Claude plugin directory as of 2026-10-08, and all twenty plugin skills are placed in the six phases where they are used). Previous: 2.8.0 (authority in the judge/build/human loop placed by artifact class — ADR-0028, partially superseding ADR-0024's human-held merge switch; harness instances that entered after v2.7.0 grounded on their concepts — the human approval gate in the harness's boundary rule, intent alignment in author-calibrated-eval, the judge pattern in jev-judgment-design and jev-skill-router; generation-audit described at its v2)

- **DOI**: [10.5281/zenodo.23238854](https://doi.org/10.5281/zenodo.23238854)

- **Companion paper**: *Harness Alignment and Harness Drift: Why Intent, Unlike Correctness, Resists Automation* — Zenodo working paper, concept DOI [10.5281/zenodo.20578272](https://doi.org/10.5281/zenodo.20578272); SSRN mirror of the same paper, DOI [10.2139/ssrn.6892740](https://doi.org/10.2139/ssrn.6892740) (Crossref-registered 2026-07-29). Cite the Zenodo DOI — the SSRN DOI identifies the same work on a second platform, not a second work

- **Author**: Tatsuya Shimomoto ([@shimo4228](https://github.com/shimo4228))

- **Origin date**: February 2026

- **License**: MIT

+ - **Status**: active and curated by hand; the skills it points to are a separate layer, synced one way from the author's Claude Code harness into akc-cycle and the standalone skill repositories. AKC is one of the long-running practice lines mapped in the author's hub, [github.com/shimo4228/shimo4228](https://github.com/shimo4228/shimo4228)

- **Repository**: [github.com/shimo4228/agent-knowledge-cycle](https://github.com/shimo4228/agent-knowledge-cycle)

- **Archive**: Zenodo (auto-archived on each GitHub Release)

- **Phases**: 6 (Research → Extract → Curate → Promote → Measure → Maintain)

- **ADRs**: 25 (ADR-0002, ADR-0003, ADR-0004, ADR-0005, ADR-0008 through ADR-0028; numbering has permanent gaps at 0001, 0006, 0007 from the v2.0.0 extraction. From ADR-0024 onward each ADR carries a `## Review-when` expiry-conditions section — ADR-0026)

- **Three core themes** (per ADR-0012, surfaced in priority order in front-door docs): (1) human cognitive resource scarcity as the central constraint, (2) intent alignment over individual correctness, (3) the cycle changes the human as much as the agent — bidirectional growth loop

- **Design principles**: 9 (Composable, Observable, Non-destructive, Tool-agnostic, Evaluation-scales, Scaffold-dissolution, Code-LLM Layering, Cognitive-economy, Genre-neutrality)

- - **Cycle skills**: 10 external repos — a mutable snapshot, not a fixed bijection (ADR-0019): search-first, learn-eval, skill-health + skill-stocktake + rules-stocktake + agent-stocktake (Curate's structural code layer and its semantic layers for skills, always-loaded rules, and agent definitions), rules-distill, skill-comply, context-sync + repo-asset-stocktake (Maintain's documentation-role and non-code-asset-liveness layers). One further repo scaffolds a concept rather than a phase: generation-audit (Scaffold Dissolution's model-generation trigger, ADR-0023). human-gate (the approval gate's presentation split) was retired from the running harness on 2026-08-02 and unlinked from the front door under ADR-0027's links-follow-running-state discipline; the repository remains published with its retirement note

+ - **Cycle skills**: carried by the akc-cycle plugin, grouped by the six phases — a mutable snapshot, not a fixed bijection (ADR-0019). Some also have standalone repositories, synced one way from the same source: search-first, learn-eval, skill-health + skill-stocktake + rules-stocktake + agent-stocktake (Curate's structural code layer and its semantic layers for skills, always-loaded rules, and agent definitions), generation-audit (Curate — re-audit when a new model generation ships; also scaffolds Scaffold Dissolution's model-generation trigger, ADR-0023), rules-distill, skill-comply + llm-as-judge (Measure), context-sync + repo-asset-stocktake (Maintain's documentation-role and non-code-asset-liveness layers). human-gate (the approval gate's presentation split) was retired from the running harness on 2026-08-02 and unlinked from the front door under ADR-0027's links-follow-running-state discipline; the repository remains published with its retirement note

- **Design-pattern skills**: 3 standalone repositories (when-code-when-llm, code-and-llm-collaboration, signal-first-research), externalized June 2026; the paired ADRs stay in-repo

- **JSON schemas**: 2 (`schemas/episode-log.schema.json`, `schemas/knowledge.schema.json`)

- **Reference implementation**: `examples/minimal_harness/` — ~500 lines, stdlib-only Python 3.10+, deterministic demo

- **Memory layers**: 3 (Raw episodes → Knowledge store → Identity/Rules)

- **Code-LLM layering patterns**: 4 (guard, filter, judge, orchestrator)

- **Rules file**: [shimo4228/akc-cycle](https://github.com/shimo4228/akc-cycle) (standalone repository; in-repo pointer at [`docs/akc-cycle.md`](docs/akc-cycle.md)) — installs the entire cycle without the skills; the same repository is also a Claude Code plugin carrying the skills of all six phases, grouped by phase

## Prior Research References

| Short name | Full citation | Relation to AKC |

|---|---|---|

| Laukkonen 2025 | Laukkonen, R. E., Friston, K., & Chandaria, S. (2025). *A Beautiful Loop: An Active Inference Theory of Consciousness*. Neuroscience & Biobehavioral Reviews. | Recursive self-modeling loop; surfaced via author's daily-research pipeline; seeded Contemplative Agent prior art |

| Hashimoto 2026 | Hashimoto, M. (2026). *My AI Adoption Journey*. [mitchellh.com](https://mitchellh.com/writing/my-ai-adoption-journey) | Harness engineering — AKC contrasts with it at a different layer (correctness vs intent alignment) |

| Meta-Harness | Lee, Y. et al. *Meta-Harness: End-to-End Optimization of Model Harnesses*. arXiv:[2603.28052](https://arxiv.org/abs/2603.28052) | Harness-optimization prior art (ADR-0017). Defines the harness as "the code that determines what information to store, retrieve, and present to the model" and improves it autonomously against benchmark scores — the correctness-axis contrast to AKC's harness alignment. Also the framing ADR-0009 rejected for AKC itself, because AKC is human-in-the-loop, not automated |

- | Thompson 2007 | Thompson, E. (2007). *Mind in Life*. Harvard University Press. | Enactivist structural coupling — post-hoc resonance noted in README References |

+ | Thompson 2007 | Thompson, E. (2007). *Mind in Life*. Harvard University Press. | Enactivist structural coupling — post-hoc resonance, formerly listed in the README's References section (recorded in ADR-0013) |

| Answer.AI llms.txt | Howard, J. & Answer.AI (2024). *llms.txt proposal*. [llmstxt.org](https://llmstxt.org/) | File format standard for this document |

| GEO-SFE | Aggarwal, P. et al. (2023). *GEO: Generative Engine Optimization*. arXiv:2311.09735 | Measurement framework; used in ADR-0010's self-application snapshot |

| Karpathy LLM Wiki | Karpathy, A. (2026). LLM Wiki pattern. | Contrast case in ADR-0010 — LLM Wikis optimize information-side scarcity; AKC optimizes attention-side scarcity |

| ECC | Mir, A. *Everything Claude Code*. [github.com/affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code) | Baseline harness AKC runs on top of; acknowledged in README |

| Contemplative Agent | Shimomoto, T. (2026). *Contemplative Agent*. [github.com/shimo4228/contemplative-agent](https://github.com/shimo4228/contemplative-agent) | Prior art for the remaining engineering substrate (ADR-0002 through ADR-0005); upstream home of the security triplet extracted from AKC in v2.0.0; downstream, the operational re-implementation of AKC in the autonomous-agent context (six phases mapped onto code, cycle run over its own episode logs, every promotion human-gated; ongoing) |

| Agent Attribution Practice | Shimomoto, T. (2026). *Agent Attribution Practice (AAP)*. doi:[10.5281/zenodo.19652013](https://doi.org/10.5281/zenodo.19652013) | Sibling genre library. The v2.0.0 extracted security triplet (ADR-0001, ADR-0006, ADR-0007) was re-expressed in AAP alongside seven additional ADRs as ten architectural decision records on accountability distribution in autonomous AI agents. AKC = cycle (mechanism); AAP = practice (content, for AI agents) |

| Voyager | Wang, G. et al. (2023). *Voyager: An Open-Ended Embodied Agent with Large Language Models*. arXiv:[2305.16291](https://arxiv.org/abs/2305.16291) | Agent-memory prior art (ADR-0013). Induces an "ever-growing skill library of executable code" from gameplay — Extract→Promote run autonomously. Named precedent AKC concedes; AKC's delta is the human approval gate over the same operation |

| Agent Workflow Memory | Wang, Z. et al. (2024). *Agent Workflow Memory*. arXiv:[2409.07429](https://arxiv.org/abs/2409.07429) | Agent-memory prior art (ADR-0013). Induces "commonly reused routines, i.e., workflows" from trajectories and feeds them back — Extract→Promote by another name |

| ReMe | Cao, Y. et al. (2025). *Remember Me, Refine Me (ReMe)*. arXiv:[2512.10696](https://arxiv.org/abs/2512.10696) | Agent-memory prior art (ADR-0013). "Dynamic procedural memory framework" that continuously refines stored memory — a Curate-and-Promote loop. AKC's delta is loop ownership, not the refinement operation |

| LangMem | LangChain (2025). *LangMem*. | Agent-memory prior art (ADR-0013). Memory tools that "control what gets stored," maintain consistency, and "optimize agent behavior through prompt refinement" — Curate/Promote, run without a human in the write path |

| Generative Agents | Park, J. S. et al. (2023). *Generative Agents: Interactive Simulacra of Human Behavior*. arXiv:[2304.03442](https://arxiv.org/abs/2304.03442) | Agent-memory prior art (ADR-0013). Introduced the reflection step that synthesizes observations into higher-level inferences — the Extract/reflection precedent |

| MemGPT | Packer, C. et al. (2023). *MemGPT: Towards LLMs as Operating Systems*. arXiv:[2310.08560](https://arxiv.org/abs/2310.08560) | Agent-memory prior art (ADR-0013). Formalizes a paged memory hierarchy between context and external store. Its binding constraint is the context window; AKC's is human attention (ADR-0010) |

| CoALA | Sumers, T. et al. (2023). *Cognitive Architectures for Language Agents (CoALA)*. arXiv:[2309.02427](https://arxiv.org/abs/2309.02427) | Agent-memory prior art (ADR-0013). Framework vocabulary (modular memory, structured action space, decision procedure) that makes the above commensurable |

| Externalization survey | Zhou, et al. (2026). *Externalization in LLM Agents*. arXiv:[2604.08224](https://arxiv.org/abs/2604.08224) | Agent-memory field map (ADR-0013). Frames the field as three coupled forms of externalization — memory, skills, protocols — coordinated by harness engineering as the unification layer; AKC sits in the memory and skills quadrants |

| SkillOps | Pu, Song & Zhao (2026). *SkillOps: Managing LLM Agent Skill Libraries as Self-Maintaining Software Ecosystems*. arXiv:[2605.13716](https://arxiv.org/abs/2605.13716) | Skill-library-maintenance prior art (ADR-0013 addendum); the origin of the skill-health rubric. Frames "skill technical debt" and a four-dimension library-health diagnosis (utility, compatibility, risk, validation); its self-maintaining loop runs without a human in the write path — AKC's delta is the approval gate (ADR-0005). The skill-health Curate code layer (ADR-0019) owns the structural compatibility dimension |

| SoK: Agentic Skills | Jiang et al. (2026). *SoK: Agentic Skills — Beyond Tool Use in LLM Agents*. arXiv:[2602.20867](https://arxiv.org/abs/2602.20867) | Skill-lifecycle field map (ADR-0013 addendum). Maps a seven-stage skill lifecycle (discovery → practice → distillation → storage → retrieval → execution → evaluation/update); AKC's six phases overlap it, the delta is loop ownership and attention-side scarcity |

| Skill usage in the wild | Liu et al. (2026). *How Well Do Agentic Skills Work in the Wild: Benchmarking LLM Skill Usage in Realistic Settings*. arXiv:[2604.04323](https://arxiv.org/abs/2604.04323) | Empirical corroboration (ADR-0013 addendum). Skill benefits degrade toward the no-skill baseline as the library grows large and uncurated — independent support for ADR-0010's claim that curation is the load-bearing, attention-bound act |

| Christiano 2018 | Christiano, P. (2018). *Clarifying "AI alignment"*. [ai-alignment.com](https://ai-alignment.com/clarifying-ai-alignment-cec47cd69dd6) | Vocabulary lineage (ADR-0017). Coined intent alignment: an aligned AI "is trying to do what H wants it to do" — motivation, not competence. AKC's harness alignment extends this to the configuration layer and across time |

| Lehman 1980 | Lehman, M. M. (1980). *Programs, Life Cycles, and Laws of Software Evolution*. Proceedings of the IEEE 68(9):1060–1076. doi:[10.1109/PROC.1980.11805](https://doi.org/10.1109/PROC.1980.11805) | Vocabulary lineage (ADR-0017). Law I (Continuing Change): an E-type program "undergoes continual change or becomes progressively less useful"; "evolution is an intrinsic, feedback driven, property of software". Lehman's driver is the world; AKC's is operator intent |

| Perry & Wolf 1992 | Perry, D. E., & Wolf, A. L. (1992). *Foundations for the Study of Software Architecture*. ACM SIGSOFT SEN 17(4):40–52. doi:[10.1145/141874.141884](https://doi.org/10.1145/141874.141884) | Vocabulary lineage (ADR-0017). "Architectural drift is due to insensitivity about the architecture" — the canonical academic name for divergence-by-insensitivity; assumes a fixed intended architecture, where AKC's target itself evolves |

| Snook 2000 | Snook, S. A. (2000). *Friendly Fire*. Princeton University Press. | Vocabulary lineage (ADR-0017). Practical drift: practice slowly uncoupling from written procedure (cited as characterized in secondary literature). Names the failure process; harness alignment names the counter-activity |

| Agent Drift | Rath, A. *Agent Drift: Quantifying Behavioral Degradation in Multi-Agent LLM Systems Over Extended Interactions*. arXiv:[2601.04170](https://arxiv.org/abs/2601.04170) | Vocabulary lineage (ADR-0017). Defines semantic drift as "progressive deviation from original intent"; its 12-entry reference list contains no classical SE literature — the vocabulary gap harness drift bridges by reference |

| Parasuraman & Manzey 2010 | Parasuraman, R., & Manzey, D. H. (2010). *Complacency and Bias in Human Use of Automation: An Attentional Integration*. Human Factors 52(3):381–410. doi:[10.1177/0018720810376055](https://doi.org/10.1177/0018720810376055) | Empirical anchor for gate complacency (position paper §6). Automation complacency is reliability-dependent (33% failure detection under constant-reliability automation vs 82% under variable-reliability) and an active attention reallocation, not laziness — structural inference for the cycle, not measurement |

| Bainbridge 1983 | Bainbridge, L. (1983). *Ironies of Automation*. Automatica 19(6):775–779. ([ScienceDirect](https://www.sciencedirect.com/science/article/pii/0005109883900468)) | Empirical anchor for deskilling (position paper §6): skills deteriorate when not used, so a formerly experienced operator monitoring an automated process may now be an inexperienced one — structural inference, not measurement |

| Benchmark audit | Moghadasi, M. N., & Ghaderi, F. (2026). *What Twelve LLM Agent Benchmark Papers Disclose About Themselves*. arXiv:[2605.21404](https://arxiv.org/abs/2605.21404) | Term disambiguation (position paper pre-deposit sweep): the only other use of "harness drift", meaning a benchmark-comparability defect — not the AKC sense (configuration layer uncoupling from operator intent) |

| Constraint Drift | Li, T. et al. (2026). *Safe Multi-Agent Behavior Must Be Maintained, Not Merely Asserted: Constraint Drift in LLM-Based Multi-Agent Systems*. arXiv:[2605.10481](https://arxiv.org/abs/2605.10481) | One of three further 2026 drift coinages audited in the position paper's pre-deposit sweep — reference list contains no classical software-evolution literature |

| Memory Drift (SSGM) | Lam, C. et al. (2026). *Governing Evolving Memory in LLM Agents: Risks, Mechanisms, and the SSGM Framework*. arXiv:[2603.11768](https://arxiv.org/abs/2603.11768) | Audited drift coinage (position paper pre-deposit sweep) — cites the agent-drift coining paper while citing no classical SE literature: the drift vocabulary propagates within the 2026 agent literature, severed from the classical lineage |

| Belief deviation | Liu, Z. et al. (2026). *Meta-Cognitive Memory Policy Optimization for Long-Horizon LLM Agents*. arXiv:[2605.30159](https://arxiv.org/abs/2605.30159) | Audited drift coinage (position paper pre-deposit sweep) — same absence of the classical software-evolution lineage |

| SDB runtime patterns | Srinivasan, V. (2026). *A Methodology for Selecting and Composing Runtime Architecture Patterns for Production LLM Agents*. arXiv:[2605.20173](https://arxiv.org/abs/2605.20173) | Concept corroboration (ADR-0013 2026-07-08 addendum). Names the stochastic-deterministic boundary (SDB) — a proposer / verifier / commit / reject-signal contract — as the load-bearing primitive of production agent runtimes; production-derived formalization of code-LLM layering (ADR-0008) |

| Context Engineering 2.0 | Hua, Q. et al. (2026). *Context Engineering 2.0: The Context of Context Engineering*. arXiv:[2510.26493](https://arxiv.org/abs/2510.26493) | Concept corroboration (ADR-0013 2026-07-08 addendum). Treats selecting and shaping what reaches the model as a discipline predating LLMs — independent convergence with signal-first and cognitive economy (ADR-0010) |

| Cognitive Divergence | Eliav, N. (2026). *The Cognitive Divergence: AI Context Windows, Human Attention Decline, and the Delegation Feedback Loop*. arXiv:[2603.26707](https://arxiv.org/abs/2603.26707) | Concept corroboration (ADR-0013 2026-07-08 addendum). Quantifies expanding model context windows against contracting human effective context span and names a self-reinforcing delegation feedback loop — external measurement of the asymmetry behind cognitive economy (ADR-0010) and the delegation-feedback divergence failure mode (ADR-0014) |

| SkillC | Lin, H. et al. (2026). *SKILLC: Learning Autonomous Skill Internalization in LLM Agents via Contrastive Credit Assignment*. arXiv:[2605.27899](https://arxiv.org/abs/2605.27899) | Concept corroboration (ADR-0013 2026-07-08 addendum). Converts the skill-injected vs skill-free rollout gap into a learning signal for internalization — scaffold dissolution operationalized as a measurable, driveable process |

| Format-Cost Separation | Agyemang, J. O. et al. (2026). *When Agents Go Quiet: Output Generation Capacity and Format-Cost Separation for LLM Document Synthesis*. arXiv:[2604.16736](https://arxiv.org/abs/2604.16736) | Concept corroboration (ADR-0013 2026-07-08 addendum). Proves deferred rendering at least as token-efficient as direct generation for any format with overhead multiplier above one — the two-stage distill pipeline (ADR-0004) upgraded from empirical rule to conditionally optimal design |

| Verification bottleneck | Huemmer, M. et al. (2026). *AI, Metacognition, and the Verification Bottleneck: A Three-Wave Longitudinal Study of Human Problem-Solving*. arXiv:[2601.17055](https://arxiv.org/abs/2601.17055) | Concept corroboration (ADR-0013 2026-07-08 addendum). Longitudinal record of the loop failure modes (ADR-0014) in a human population: AI reliance heaviest on the hardest tasks, exactly where verification confidence and accuracy are lowest — the bidirectional growth loop observed running in reverse |

| Agent-human interaction security | Wang, P. et al. (2026). *Reframing LLM Agent Security as an Agent-Human Interaction Problem*. arXiv:[2605.24309](https://arxiv.org/abs/2605.24309) | Concept corroboration (ADR-0013 2026-07-08 addendum). 59 academic papers vs 21 production systems: academically favored mechanisms at zero production deployment while human-centric mechanisms (policy, runtime approval, scoping) dominate — the intent-alignment theme's industry–academia gap, measured |

| EvoAgentBench | Gao, X. et al. (2026). *EvoAgentBench: Benchmarking Agent Self-Evolution via Ability Transfer*. arXiv:[2607.05202](https://arxiv.org/abs/2607.05202) | Controlled ability-transfer corroboration (ADR-0013 2026-07-23 addendum) and the evidence base of ADR-0022. Under an ability-supported yet instance-disjoint split (528/267), curated ability content (the curator-side Anchor Skill reference, not a deployable method) transfers positively in all 24 cells while no automatic extraction method (Memento, ReasoningBank, GEPA) sustains positive gain in all settings — negative transfer to −36.3 points in software engineering. First controlled comparison on the human-gate delta axis; motivates the held-out transfer completion test for dissolution |

| Memo, not memory | Xu, B., Dai, X., & Zhang, K. (2026). *Contextual Agentic Memory is a Memo, Not True Memory*. arXiv:[2604.27707](https://arxiv.org/abs/2604.27707) | Paradigm challenge (ADR-0013 2026-08-08 addendum) — the first entry disputing the class AKC belongs to rather than conceding precedent. Retrieval-based memory "implements lookup," not memory; Complementary Learning Systems framing says agents have the fast hippocampal half without slow neocortical consolidation. Theorem 1 (v2, 2026-08-05) quantifies a Ω(k²/d) sample-complexity separation against a parametric learner on compositionally novel tasks. v2 proposes co-existence, not abandonment: episodic retrieval is the legitimate fast-learning half plus a consolidation channel into persistent adaptive state. Lands on ADR-0009's harness-portability trade (AKC's durable output is text and touches no weights, so it has no such channel and claims none), not on the approval gate |

## What is the Agent Knowledge Cycle (AKC)?

Agent Knowledge Cycle (AKC) is defined as a knowledge cycle for AI agents centered on the scarcity of human cognitive resources — attention and judgment — as the resource that does not scale with the model. Its purpose is to keep the agent's behavior aligned with the operator's evolving intent across sessions, not merely individually correct on each output, while the operator's judgment about good agent behavior also sharpens through use — making AKC a bidirectional growth loop in which agent and human co-develop. The mechanism is six composable phases — Research, Extract, Curate, Promote, Measure, Maintain — that keep skills, rules, and documentation aligned with the operator's intent. AKC was first proposed and implemented by Tatsuya Shimomoto in February 2026 and is published under DOI `10.5281/zenodo.23238854` with MIT license. AKC ships as specifications, JSON schemas, twenty-five Architecture Decision Records (ADR-0002 through ADR-0005, ADR-0008 through ADR-0028; the numbering has permanent gaps at 0001, 0006, and 0007 from the v2.0.0 extraction of the security triplet), three design-pattern skills (externalized to standalone repositories), one rules file and its plugin (externalized to the standalone shimo4228/akc-cycle repository, with an in-repo pointer at `docs/akc-cycle.md`), and one dependency-free Python reference implementation at `examples/minimal_harness/` (~500 lines, stdlib only).

## What is AKC's central constraint?

AKC's central constraint is defined as the scarcity of human cognitive resources — attention and judgment — not agent capability, context-window size, or information volume. ADR-0010 names this as a design principle: human cognitive resource is the bottleneck. As agent capability grows, the scarce resource migrates from machine to human. Every AKC phase is shaped to protect the operator's fixed daily budget: signal-first intake in Research, promotion of recurring decisions to rules so the same judgment is not re-made, observable compliance measurement so manual re-auditing is not required, and front-loaded dialogue because intent misalignment discovered at review time costs more than the conversation that would have prevented it. ADR-0010 contrasts AKC with information-side architectures (LLM Wikis, knowledge bases): they optimize for searchability of accumulated content; AKC optimizes for what the human does *not* have to read, hold, or re-decide.

## How does AKC frame intent alignment?

Intent alignment is defined in AKC as the property that the agent's behavior stays consistent with the operator's evolving intent across sessions, not merely with a static specification. AKC distinguishes this from correctness, which is the property that an output passes specific checks (tests, types, linters). An agent can satisfy every correctness check and still drift from intent, because intent itself moves as the operator's judgment sharpens through use. AKC's design choices reflect this distinction: Design Principle #3 (Non-destructive) — propose, then wait for confirmation — keeps every change at a checkpoint where intent can be re-stated, and pre-implementation dialogue is treated as a cognitive-economy investment, not as friction. The same distinction explains how AKC differs from harness engineering: harnesses optimize correctness on the first try, while AKC keeps the harnesses themselves aligned with intent as that intent evolves. Without this distinction, repeated maintenance cycles become drift-correction cycles, and the human's attention gets spent reconstructing what went wrong rather than directing what comes next.

## How does AKC relate to harnesses?

A harness is the operational scaffold an agent runs through — tools, prompts, memory APIs, file-system adapters, skills, rules, and documentation. Claude Code, Everything Claude Code (ECC), Claude Code's built-in skills system, and Mitchell Hashimoto's harness engineering all sit at this layer. AKC's core object is the growth cycle that turns experience into durable behavior-shaping knowledge and keeps those artifacts aligned with operator intent over time. The cycle can be packaged as harness artifacts (rules, skills, examples), and it can run inside Claude Code or any comparable harness; the point of ADR-0009 (2026-04-11) was to prevent layer confusion, not to deny that AKC ships harness-facing artifacts. The tagline "agent behavior compounds, human judgment sharpens" signals the bidirectional loop: the cycle changes the human too, not only the agent (ADR-0021 records the 2026-07 replacement of the earlier "grows with the people who shape it" phrasing, which had collided with agent-centric autonomous-growth product marketing).

## What is harness alignment, and how does it differ from harness optimization?

Harness alignment is defined as the continuous, human-gated activity of keeping an agent's harness — its configuration layer of skills, rules, prompts, and documentation — aligned with the operator's evolving intent. The term is derived from established literature rather than coined fresh (ADR-0017): it extends intent alignment (Christiano, 2018 — an agent trying to do what its operator wants it to do) in two directions, from the agent's behavior to the artifacts that shape behavior, and across time, because alignment is sustained through a cycle rather than configured once (cf. Lehman's Law of Continuing Change, 1980). Three properties define the activity and hold simultaneously: it is **continuous**, **human-gated**, and **bidirectional** — the loop's own running moves its own target, because verifying intent sharpens the judgment doing the verifying. The alignment target is operator intent, not model values — this is not an AI-safety value-alignment claim. Its failure mode is harness drift: the gradual uncoupling of the harness from operator intent when the cycle does not run — skills go stale, rules stop matching practice, documentation diverges from code — named in lineage with architectural drift (Perry & Wolf, 1992: divergence by insensitivity), practical drift (Snook, 2000: practice uncoupling from written procedure), and agent drift (arXiv:2601.04170: "progressive deviation from original intent" at the behavioral level). The contrast term is harness optimization (Meta-Harness, arXiv:2603.28052): autonomous, score-driven improvement of harness code against benchmark scores — the correctness axis, with no operator intent in the loop. The two are complementary, not competing: a harness can score better on a fixed benchmark while sliding away from what its operator now wants. In this vocabulary, AKC's six phases operationalize harness alignment: Measure and Maintain detect harness drift; Curate and Promote correct it through the human approval gate (ADR-0005). Both terms are defined against the literature in a companion working paper deposited from this line: Shimomoto, T. (2026), "Harness Alignment and Harness Drift: Why Intent, Unlike Correctness, Resists Automation", Zenodo, DOI 10.5281/zenodo.20578272.

## What does the position paper "Harness Alignment and Harness Drift" claim?

The position paper — Shimomoto, T. (2026), *Harness Alignment and Harness Drift: Why Intent, Unlike Correctness, Resists Automation*, Zenodo working paper, concept DOI [10.5281/zenodo.20578272](https://doi.org/10.5281/zenodo.20578272) (v1: 10.5281/zenodo.20578273), deposited 2026-06-07 from this research line — defines both terms against the literature; ADR-0017 is the repository-side canonical definition record. Its thesis: harness engineering (Hashimoto, 2026) and harness optimization (Meta-Harness, arXiv:2603.28052) automate against fixed, checkable criteria — a failing test, a benchmark score — while harness alignment's criterion, operator intent, lives in the operator and moves; intent has no verifier outside the operator. The paper's structural argument (§3): any automated intent-check must freeze intent into a stated criterion; a frozen criterion is a specification, and checking against a specification is correctness work — so the automatable part of intent alignment reduces, piece by piece, to correctness work, and the residue is the moving criterion itself. The three defining properties are the shape of that residue: **continuous** (a moving criterion needs a recurring loop, not a one-time configuration — Lehman's Law I is the structural parallel), **human-gated** (the moving criterion lives only in the operator, so the gate is where intent enters the loop — extrinsic metacognition by design, not by immaturity), and **bidirectional** (verifying intent is an act of judgment that sharpens the judgment doing the verifying, so the loop moves its own target). The six-phase cycle operationalizes the activity (§5) over a memory boundary separating freely-writable records from gated behavior-shaping artifacts — the place where the human-gated property becomes architecture: "What can be verified without the operator runs unattended; every change that shapes behavior passes the gate, and intent enters the loop with it" (§5). The two running instances (the author's daily operation of a commercial coding harness, and Contemplative Agent running the cycle over its own logs) are offered as portability evidence, not efficacy. Failure has two layers (§6): artifact-side harness drift, and a human-side twin — gate complacency, deskilling, delegation-feedback divergence — anchored in the automation-complacency literature (Parasuraman & Manzey, 2010: operators monitoring constant-reliability automation detected 33% of its failures, versus 82% under variable-reliability automation) and the ironies-of-automation literature (Bainbridge, 1983), held as structural inference, not measurement. A bibliographic finding (§4, §6): the reference lists of four 2026 drift coinages — agent drift (arXiv:2601.04170), constraint drift (arXiv:2605.10481), memory drift (arXiv:2603.11768), belief deviation (arXiv:2605.30159) — contain no classical software-evolution literature (no Lehman, no Perry & Wolf, no Parnas, no Snook); harness drift, defined with explicit lineage to both bodies, bridges that disconnection by reference. Disambiguation for retrieval: the only other use of the term "harness drift" found in a pre-deposit sweep (Moghadasi & Ghaderi, 2026, arXiv:2605.21404) means a benchmark-comparability defect — results produced under different scaffolds circulating under the same benchmark name — not a configuration layer's uncoupling from operator intent; no non-author use of "harness alignment" as a defined term was found. Scope: a position paper, not an empirical study; external adoption of both terms is n=0 at publication; the judgments come from a months-old practice and are offered for other operators to test.

## What are the six phases of AKC?

The six AKC phases are defined as follows. **Research** — search broadly, filter strictly by signal; only information that would change the next action is admitted. **Extract** — capture reusable patterns from a session with quality evaluation before persisting. **Curate** — periodically audit accumulated skills and rules for redundancy, staleness, and silence. **Promote** — elevate patterns whose recurrence has itself become the signal, from the probabilistic skills layer to the deterministic rules layer; the trigger is holistic judgment, not a numeric threshold. **Measure** — verify behavioral change quantitatively through observable behavior, not subjective impression. Observable behavior is not only tool calls: thinking-centric phases (Research, Curate) carry their compliance in agent text — reasoning, verdicts, and plans — so a Measure instrument must promote agent text to observable events before scoring, or it systematically under-reports judgment-phase compliance (ADR-0016). Alongside that semantic compliance layer, Measure carries a deterministic telemetry layer — harness-side usage logging that records whether skills fire at all, a consumer-independent measurement whose output feeds Curate's silence check. **Maintain** — keep documentation roles clean so each file serves exactly one of four roles (Context, Architecture, Decisions, External), and audit the repository's other non-code assets — tool configs, CI workflows, runbooks — for consumers that have vanished. Phases run as a closed loop; experience feeds Research, rules emerge from Promote.

## Why is Research defined as signal-first?

Signal-first Research is defined as filtering at intake rather than after accumulation. ADR-0010 (2026-04-18) names this principle explicitly. Before v1.8, Research only told the agent what to *find*; after v1.8, it also tells the agent what to *refuse to load*. The rule: before searching, define the signal — what information would actually change the next action? Search broadly; intake narrowly. Information that does not change an action does not deserve to be held, because intake consumes human attention, and unspent attention is the cycle's scarce resource. Exploration and learning phases are legitimate exceptions and must be named explicitly when taken.

## Who is the intended audience of AKC?

AKC is written for two audiences. The primary audience is the operator of an AI coding agent — someone running Claude Code, a custom harness, or any agent with persistent configuration — who has accumulated enough skills and rules that maintenance has become a real cost. The secondary audience is researchers and authors comparing approaches to agent memory, skill management, or human-AI co-development. AKC is not aimed at end users of AI products; it is aimed at the humans who configure and sustain coding agents. The rules file (standalone repository shimo4228/akc-cycle, pointed to by `docs/akc-cycle.md`) is also directly consumable by LLM agents themselves.

## How does an agent install AKC in under a minute?

AKC's install path is defined as a single file download from the standalone rules repository:

```bash

mkdir -p ~/.claude/rules

curl -fsSL https://raw.githubusercontent.com/shimo4228/akc-cycle/main/rules/common/akc-cycle.md \

-o ~/.claude/rules/akc-cycle.md

```

Claude Code loads every Markdown file under `~/.claude/rules/`; other harnesses take the file wherever they read rules from.

- That rule file distills all six phases into behavioral principles any AI agent can follow through natural conversation. No skills, no plugins, no CLI tools are required. Operators who want guided step-by-step workflows per phase can additionally install the akc-cycle Claude Code plugin (`/plugin marketplace add shimo4228/akc-cycle`, then `/plugin install akc-cycle@akc-cycle`), which carries skills for all six phases, grouped by phase: Research (search-first), Extract (learn-eval, skill-creator), Curate (skill-health, skill-stocktake, rules-stocktake, agent-stocktake, generation-audit, harness-boundary), Promote (rules-distill, review-to-lint), Measure (skill-comply, measurement-discipline, llm-as-judge, author-calibrated-eval, jev-judgment-design), Maintain (context-sync, repo-asset-stocktake, adr-writer, verify-bootstrap). The phase grouping is a mutable snapshot (ADR-0019). Some of these skills also have standalone repositories; akc-cycle's README (Single skills) says which to install together. The plugin adds skills only (no hooks, MCP servers, or settings); Claude Code plugins have no slot for always-loaded rules (as of 2026-10-08), so the rules file is installed separately. Rules and skills coexist — rules ensure the cycle runs even when skills are not triggered.

+ That rule file distills all six phases into behavioral principles any AI agent can follow through natural conversation. No skills, no plugins, no CLI tools are required. Operators who want guided step-by-step workflows per phase can additionally install the akc-cycle Claude Code plugin (`/plugin marketplace add shimo4228/akc-cycle`, then `/plugin install akc-cycle@akc-cycle`), which carries skills for all six phases, grouped by phase: Research (search-first), Extract (learn-eval, skill-creator), Curate (skill-health, skill-stocktake, rules-stocktake, agent-stocktake, generation-audit, harness-boundary), Promote (rules-distill, review-to-lint), Measure (skill-comply, measurement-discipline, llm-as-judge, author-calibrated-eval, jev-judgment-design), Maintain (context-sync, repo-asset-stocktake, adr-writer, verify-bootstrap). The phase grouping is a mutable snapshot (ADR-0019). Some of these skills also have standalone repositories; akc-cycle's README (Single skills) says which to install together. The plugin adds skills only (no hooks, MCP servers, or settings); Claude Code plugins have no slot for always-loaded rules (as of 2026-10-08), so the rules file is installed separately. Some skills run bundled Python scripts with `uv` and Python 3.11 or later; `skill-comply` and `skill-stocktake` start separate `claude -p` sessions that use the operator's Claude usage. Some skills write before asking: `context-sync` edits existing documentation, ADRs included, and lists every file it edited so the operator signs off afterwards by keeping or reverting the edits; `review-to-lint` and `verify-bootstrap` have no confirmation step before they write. Rules and skills coexist — rules ensure the cycle runs even when skills are not triggered.

## What does scaffold dissolution mean in AKC?

Scaffold dissolution is defined as the property that AKC's skills become unnecessary once the cycle is internalized. The scaffold-dissolution principle is Design Principle #6 and is documented in [`docs/scaffold-dissolution.md`](docs/scaffold-dissolution.md). Practically: skills are probabilistic scaffolding that help an operator and agent run the cycle before it becomes habit. As Curate and Promote decisions accumulate, the judgment they require gets absorbed into conversation patterns and rules. Success is measured not by skill count but by whether the cycle runs naturally without explicit skill invocation. Rules remain load-bearing; skills fade. Completion is certified in two stages (ADR-0022, experimental): same-context ablation indistinguishability — running compliance with and without the rule loaded — is necessary evidence but cannot separate internalization from the surrounding context carrying the behavior; the completion evidence is held-out transfer, the same judgment reproducing in a context that shares the principle but not the surface instances. Retirement decisions name their evidence class, from four (ADR-0023): silence (telemetry shows the artifact unused — retires an artifact, claims nothing about internalization), ablation (necessary), transfer (the completion certificate), or generation review (the substrate's model generation changed and the rule was written against the previous generation's failure modes — an audit scheduled by the model release cadence, because the first three classes all detect an absence and are structurally blind to a rule whose firing is itself the cost). The fourth class corresponds to the fourth dissolution mechanism, model-side capability turnover: a constraint's premise expires at a generation boundary while its instruction still has to be read and reconciled, making it the only pathway that leaves the scaffold actively harmful rather than merely idle (documented in `docs/scaffold-dissolution.md` with the 2026-07-25 observation — a rules layer cut 56% after the vendor reported an 80% system-prompt reduction with no evaluation loss).

## How does AKC relate to ECC (Everything Claude Code)?

- Everything Claude Code (ECC) is defined as the baseline agent harness AKC runs on top of. ECC ships skills and rules for Claude Code; AKC provides the maintenance cycle that keeps such a harness coherent as it grows. The README's Acknowledgments section credits ECC directly: AKC emerged from months of daily ECC use, during which the author's own accumulated skills and rules proliferated faster than they could be tracked. The six-phase cycle is the shape that recurring maintenance work took. The first five cycle skills were contributed to ECC between February and March 2026; context-sync was developed independently.

+ Everything Claude Code (ECC) is defined as the baseline agent harness AKC runs on top of. ECC ships skills and rules for Claude Code; AKC provides the maintenance cycle that keeps such a harness coherent as it grows. The Origin & Acknowledgments section below (moved from the README) credits ECC directly: AKC emerged from months of daily ECC use, during which the author's own accumulated skills and rules proliferated faster than they could be tracked. The six-phase cycle is the shape that recurring maintenance work took. The first five cycle skills were contributed to ECC between February and March 2026; context-sync was developed independently.

## What knowledge bodies can run through the AKC cycle?

Any coherent body of agent knowledge can run through the cycle: behavioral patterns (e.g., a recurring two-stage distill pattern), domain expertise (e.g., a compliance catalogue), or constitutional values (e.g., an agent's axioms and identity statements). ADR-0011 (2026-04-19) declares this explicitly as genre neutrality — the cycle is a mechanism, and content is the downstream project's concern. AKC takes no position on what flows through the cycle and ships no skill tied to any specific knowledge domain. Three falsifiable commitments back the position: (1) no future AKC ADR encodes domain-specific content beyond what the six phases require; (2) AKC ships only cycle-mechanic skills — the design-pattern skills (when-code-when-llm, code-and-llm-collaboration, signal-first-research), externalized to standalone repositories in June 2026, all describe how the cycle works, not what it works on; (3) external projects may cite AKC as their cycle substrate while retaining their own content. Two concrete examples ship in the repository to make this tangible: `examples/minimal_harness/` runs the cycle on behavioral patterns (mechanism demo), and `examples/constitution_amend/` points at contemplative-agent's Constitution-amend workflow as an instance of the same cycle running on constitutional values (descriptive only; implementation lives upstream). The security triplet (ADR-0001, ADR-0006, ADR-0007) was extracted in v2.0.0 precisely because it violated these commitments — it encoded a genre-specific threat model that belonged with contemplative-agent, not with AKC. See the ADR-0009 addendum (2026-04-19) for the extraction record.

## How does the human approval gate scale when tasks outnumber attention? (the judge/build/human three-role loop)

The judge/build/human three-role loop is defined as the operational form the human approval gate (ADR-0005) takes under attention scarcity (ADR-0010) when the artifact upstream of the gate is an open-ended task ledger rather than a single proposed change. Filing a task is the cheapest operation in the system, so ledgers grow; in the operator's harness the observed ledgers held no dispatchable work by 2026-08-17 — the bottleneck was judgment, not implementation. The loop assigns three roles: a **judge tier** (one stronger-model session per repository) verifies each task's premise against the code before implementation, decides whether the task is worth doing at all, dispatches accepted work, and independently inspects results; a **build tier** (a fresh session per task) implements, records evidence in commit bodies, and halts on a refuted premise; the **human** holds direction-setting and admission, and answers a digest of one decision per message. As recorded on 2026-09-01 the human also retained the final switch — the merge into main — for every task; ADR-0028 (2026-09-25) narrowed that to a protected class: what ADR-0005 gates (rules, skills, identity, documents that describe behavior), the control plane, and the verification machinery stay human at merge, while admitted task output outside that class merges once a deterministic gate passes and the judge tier's inspection passes, with the human's authority over it placed at admission and in a revert-count withdrawal condition (evidence: ten days of single-operator practice since the harness change of 2026-09-15, stated as thin). Model judgment is spent to conserve human judgment. AKC records the role topology only (ADR-0024); ledger formats, claim/lease mechanics, and scheduling are harness content, recorded as relation facts on the claude-harness ecosystem node. Evidence is roughly two weeks of single-operator practice (2026-08-17 through 2026-09-01), stated as such in the ADR.

## Who reads the cycle's artifacts? (LLM-first artifact readability)

The default reader, editor, and reviewer of the cycle's artifacts — skills, rules, distilled knowledge, tests, decision records — is the next session's LLM (ADR-0025). The operator confirmed on 2026-08-31 that humans read only the README and the surface text of outputs. Optimizing for the LLM reader is the quality bar itself, a change of audience rather than a lowering of it: the LLM reader is often less forgiving than a human one, and ambiguous, clever, or bloated artifacts come back as bounced edits. LLM readability consists of locality (self-contained units that fit in context) over deep abstraction, explicitness over cleverness, and types and invariant comments as beacons; the measuring stick is context economy, not human cognitive load. What is preserved is verifiability, not readability: prose explanations are derivable on demand, while the preservation layer — types, tests, frozen goldens, stated invariants — cannot be regenerated. The enforcer of the standard is the machine gate, not the human eye; an artifact that fails its gate is unacceptable even if nobody reads it. The human-readability budget has one line item: the README (ADR-0020's minimal floor) and output surface text. ADR-0025 is adjacent to ADR-0008, not overlapping: 0008 answers who checks (code vs. LLM), 0025 answers who reads.

## What may AKC's core contain? (mental model / instance)

AKC core owns the mental model — judgments (ADRs), concepts (graph.jsonld), and the cycle structure — and nothing else (ADR-0027, superseding the earlier "mechanism-only inclusion rule" vocabulary). Running instances — skills, rules, hooks, gates, loops — are owned by downstream repositories and linked from AKC as first-class grounding: every mechanism concept carries an edge to at least one public instance where one exists (an implements-direction edge in the graph, a link in the front door), and a concept with no public instance says so rather than hiding it. Two prohibitions remain: inlining instance content into core (duplication), and taking a position on domain genre — which behavioral patterns, domain expertise, or constitutional values flow through the cycle (ADR-0011, unchanged). Links follow the running state: when an instance retires from the running practice, its front-door link is removed or annotated with a date. The first recorded application is the human-gate rule, retired from the operator's harness on 2026-08-02 and unlinked from the README on 2026-09-01; the repository remains published as history. The gate concept was re-grounded on 2026-09-25 in claude-harness's always-loaded boundary rule, in the running harness since 2026-09-15. The earlier vocabulary had conflated domain genre (stays out) with running instances (ground the model) under one word, "content" — the 2026-09-01 author judgment that triggered ADR-0027 was that this conflation had begun obstructing understanding: a mechanism without a visible instance cannot be understood.

## How does AKC keep stored judgment from outliving its premises? (expiry-conditioned knowledge)

Expiry-conditioned knowledge (ADR-0026) applies the staleness worldview — external knowledge in the LLM field goes stale on a roughly one-week scale — to the cycle's own storage. Every stored judgment states what observation or premise failure would void or weaken it; intake states its as-of date; a recommendation that cannot name an expiry condition is treated as freshness-unknown and weighted weakly. Structurally, the AKC ADR format carries a `## Review-when` section (placed after Decision) from ADR-0024 onward — deliberately not backfilled into ADR-0002 through ADR-0023, because a retrofitted expiry condition would be invented post hoc; older ADRs are read by their Context premises and Date. Weakening is annotated in place, dated, never deleted. Rejection records receive the same reading: they are dated hypotheses, not permanent vetoes — divergence-stage ideation must not use them as refutation, and verification against them happens only at adoption time. ADR-0026 gives ADR-0019's provisionality ("the cycle's structure is held lightly") a per-decision instrument, and generation review's external clock (ADR-0023) is one class of expiry condition. The mechanism was imported from the operator's harness practice, where by the operator's own report — a subjective observation with zero recorded case-level instances at baseline, stated as such in the ADR — a declaration alone ("decision records are scaffolds") had not changed reading behavior, so the structural section was adopted instead.

## Where was AKC's extracted security triplet re-expressed?

AKC v2.0.0 extraction is defined as the removal of ADR-0001, ADR-0006, and ADR-0007 from AKC — a genre-specific threat model that did not belong with the mechanism-neutral cycle. The three were re-expressed in [Agent Attribution Practice (AAP)](https://doi.org/10.5281/zenodo.19652013) (DOI `10.5281/zenodo.19652013`, published 2026-04-19) alongside seven additional ADRs (Causal Traceability, Scaffolding Visibility, One Agent One Human, Human Approval Gate, Single External Adapter, Triage Before Autonomy, Phase Separation), for ten ADRs total. AAP introduces a three-tier prohibition-strength hierarchy: Security by Absence > Deterministic Prohibition at the Scaffolding Layer (newly formalized) > Untrusted Content Boundary — the argumentative spine the AKC triplet lacked in v1.x. AAP is the canonical harness-neutral home for those judgments from v0.1.0 forward. AKC = cycle (how knowledge flows); AAP = practice (how attribution distributes in autonomous AI agents).

## What has the cycle's own operation produced downstream?

- The daily operation the cycle runs in did not keep its outputs inside the operator-agent pair. Re-implementations: Contemplative Agent (concept DOI 10.5281/zenodo.19212118) is the operational re-implementation of AKC in the autonomous-agent context — its pipeline maps the six phases onto code, the agent runs the cycle over its own episode logs with no fine-tuning and no labeled training data, and every promotion passes through a human approval gate; the demonstration is ongoing. AKC MCP ([github.com/shimo4228/akc-mcp](https://github.com/shimo4228/akc-mcp)) exposes the cycle's cognitive operations as an MCP server any agent can plug into — a third encoding alongside the Markdown skills and Contemplative Agent's code pipeline. claude-harness ([github.com/shimo4228/claude-harness](https://github.com/shimo4228/claude-harness)) ships the operator's harness as one bundled distribution — as of 2026-09 an origin-tracked library of some 58 skills (the six cycle skills among them), a worldview rules layer (always-loaded rules such as LLM-first artifact readability and knowledge staleness, whose AKC-side judgments are ADR-0025 and ADR-0026), deterministic hooks and machine gates, and a public rfcs/ task ledger operated by the judge/build/human three-role triage loop (ADR-0024), whose build sessions run as cloud sessions by default since 2026-09-24. Three of its instances ground concepts that had no running instance before: its always-loaded boundary rule (rules/common/boundary.md, since 2026-09-15) is the running instance of the human approval gate (ADR-0005) — one list of what is handed to the human; the author-calibrated-eval skill (2026-09-25) grounds intent alignment — the author's blind reading decides what is worth reading, an LLM judge only screens fidelity to the source, code checks form; the jev-judgment-design skill (2026-09-23) grounds the code-LLM judge pattern (ADR-0008) — closed judgments move to a typed judgment model, code decides acceptance. Three older claude-harness skills ground concepts the same way: harness-boundary asks, before a mechanism enters the harness, whether the next model generation will make it unnecessary (Scaffold Dissolution at design time); review-to-lint moves the machine-decidable items of an LLM reviewer's checklist into a deterministic script (code-LLM layering applied to review); adr-writer requires a Review-when section in every decision record and routes decisions below the ADR bar into commit bodies carrying the same Context / Decision / Review-when triple (expiry-conditioned knowledge). llm-as-judge ([github.com/shimo4228/llm-as-judge](https://github.com/shimo4228/llm-as-judge)) grounds the LLM side of the judge pattern — binary checks as evidence, one named verdict, no score aggregation. jev-skill-router ([github.com/shimo4228/jev-skill-router](https://github.com/shimo4228/jev-skill-router)) is a further judge-pattern instance: skill selection as a typed judgment, shadow-first, with its README recording why it is unlikely to help a strong model as a router. herdr-toolkit ([github.com/shimo4228/herdr-toolkit](https://github.com/shimo4228/herdr-toolkit)) was, in the operator's practice, the build-dispatch substrate of that three-role loop until 2026-09-24 and remains the path for build sessions that must run locally (relation fact only; the loop's mechanism is recorded in AKC). Crystallized research lines: Authorship Strategy (DOI 10.5281/zenodo.20263316) frames itself as the diffusion side of AKC's mechanism — AKC defines how knowledge cycles inside the operator-agent pair; it addresses how the cycle's outputs diffuse outside it. Attention, Not Self (DOI 10.5281/zenodo.20262112) is a sibling research line federated at the research-ecosystem level. doctrine-corpus (DOI 10.5281/zenodo.20337008) is a bilingual judgment-eliciting Q&A corpus with AKC as one of its four source lines (ADRs and glossary harvested into the corpus). existence-proof (DOI 10.5281/zenodo.20558800) is a pre-line working repository complementing Authorship Strategy. The pre-AKC ancestor of the Research phase is the author's daily-research pipeline ([github.com/shimo4228/daily-research](https://github.com/shimo4228/daily-research)), documented in docs/inspiration.md. The canonical relationship map of the whole program lives in the hub repository's graph.jsonld ([github.com/shimo4228/shimo4228](https://github.com/shimo4228/shimo4228)).

+ The daily operation the cycle runs in did not keep its outputs inside the operator-agent pair. Re-implementations: Contemplative Agent (concept DOI 10.5281/zenodo.19212118) is the operational re-implementation of AKC in the autonomous-agent context — its pipeline maps the six phases onto code, the agent runs the cycle over its own episode logs with no fine-tuning and no labeled training data, and every promotion passes through a human approval gate; the demonstration is ongoing. AKC MCP ([github.com/shimo4228/akc-mcp](https://github.com/shimo4228/akc-mcp)) exposes the cycle's cognitive operations as an MCP server any agent can plug into (alpha, unchanged since 2026-04-10 per its README) — a third encoding alongside the Markdown skills and Contemplative Agent's code pipeline. claude-harness ([github.com/shimo4228/claude-harness](https://github.com/shimo4228/claude-harness)) ships the operator's harness as one bundled distribution — as of 2026-09 an origin-tracked library of some 58 skills (the six cycle skills among them), a worldview rules layer (always-loaded rules such as LLM-first artifact readability and knowledge staleness, whose AKC-side judgments are ADR-0025 and ADR-0026), deterministic hooks and machine gates, and a public rfcs/ task ledger operated by the judge/build/human three-role triage loop (ADR-0024), whose build sessions run as cloud sessions by default since 2026-09-24. Three of its instances ground concepts that had no running instance before: its always-loaded boundary rule (rules/common/boundary.md, since 2026-09-15) is the running instance of the human approval gate (ADR-0005) — one list of what is handed to the human; the author-calibrated-eval skill (2026-09-25) grounds intent alignment — the author's blind reading decides what is worth reading, an LLM judge only screens fidelity to the source, code checks form; the jev-judgment-design skill (2026-09-23) grounds the code-LLM judge pattern (ADR-0008) — closed judgments move to a typed judgment model, code decides acceptance. Three older claude-harness skills ground concepts the same way: harness-boundary asks, before a mechanism enters the harness, whether the next model generation will make it unnecessary (Scaffold Dissolution at design time); review-to-lint moves the machine-decidable items of an LLM reviewer's checklist into a deterministic script (code-LLM layering applied to review); adr-writer requires a Review-when section in every decision record and routes decisions below the ADR bar into commit bodies carrying the same Context / Decision / Review-when triple (expiry-conditioned knowledge). llm-as-judge ([github.com/shimo4228/llm-as-judge](https://github.com/shimo4228/llm-as-judge)) grounds the LLM side of the judge pattern — binary checks as evidence, one named verdict, no score aggregation. jev-skill-router ([github.com/shimo4228/jev-skill-router](https://github.com/shimo4228/jev-skill-router)) is a further judge-pattern instance: skill selection as a typed judgment, shadow-first, with its README recording why it is unlikely to help a strong model as a router. herdr-toolkit ([github.com/shimo4228/herdr-toolkit](https://github.com/shimo4228/herdr-toolkit)) was, in the operator's practice, the build-dispatch substrate of that three-role loop until 2026-09-24 and remains the path for build sessions that must run locally (relation fact only; the loop's mechanism is recorded in AKC). Crystallized research lines: Authorship Strategy (DOI 10.5281/zenodo.20263316) frames itself as the diffusion side of AKC's mechanism — AKC defines how knowledge cycles inside the operator-agent pair; it addresses how the cycle's outputs diffuse outside it. Attention, Not Self (DOI 10.5281/zenodo.20262112) is a sibling research line federated at the research-ecosystem level. doctrine-corpus (DOI 10.5281/zenodo.20337008) is a bilingual judgment-eliciting Q&A corpus with AKC as one of its four source lines (ADRs and glossary harvested into the corpus). existence-proof (DOI 10.5281/zenodo.20558800) is a pre-line working repository complementing Authorship Strategy. The pre-AKC ancestor of the Research phase is the author's daily-research pipeline ([github.com/shimo4228/daily-research](https://github.com/shimo4228/daily-research)), documented in docs/inspiration.md. The canonical relationship map of the whole program lives in the hub repository's graph.jsonld ([github.com/shimo4228/shimo4228](https://github.com/shimo4228/shimo4228)).

## When does AKC's bidirectional loop fail, and what are AKC's limitations?

AKC's bidirectional growth loop (Theme 3) has a failure twin: the same coupling that lets sustained supervision sharpen the operator's judgment can, under different conditions, dull it. ADR-0014 names three mechanism-level failure modes. **(i) Gate complacency / automation bias** — as the agent becomes more reliable, a stream of usually-correct proposals trains the operator to approve by default; the approval gate (ADR-0005) is still clicked, but the judgment behind the click thins to a reflex. This is worst exactly where Theme 1 bites: under a constrained attention budget, trusting the proposal is the cheapest action. **(ii) Deskilling** — the tacit expertise required to notice a subtly-wrong proposal is maintained by exercise; if the human stops doing the underlying work and only reviews output, that faculty atrophies until a good proposal is indistinguishable from a plausible one. **(iii) Delegation-feedback divergence** — the most dangerous mode: the agent keeps acting on the operator's behalf, but the feedback that would correct it no longer reaches a human positioned to use it, so the two ends of the loop drift apart while the machinery keeps producing output no human is meaningfully steering. These three modes are the human-side layer of harness alignment's two-layer failure; the artifact-side layer is harness drift (ADR-0017). The two compound — a complacent gate accelerates harness drift — but they are distinct failures, recorded separately. The position paper (§6) locates the first two modes in established empirical literatures — gate complacency as an instance of automation complacency (Parasuraman & Manzey, 2010), deskilling as Bainbridge's (1983) irony of automation — held as structural inference, not measurement on this cycle.

AKC does not claim to prevent these failures; it claims its existing structure resists them more than an autonomous or passive-consumption alternative would. The defenses are structural, not exhortations to "be careful." The Human Approval Gate (ADR-0005) is a circuit-breaker, not a delay: with no "auto-approve after N days" and no "approved by the LLM itself" path, the gate's *existence* cannot be eroded by the loop itself — only by the human choosing to attend less, which keeps the failure on the human side of the boundary where it can be noticed. Curate and Promote are active judgment acts, not passive consumption: they ask the human to *decide* what to keep and what to promote, which exercises exactly the faculty deskilling erodes. And the gate forces articulation — the operator reviews a diff or proposal file, edits it, and commits under their name — which is structurally heavier than a yes/no click and harder to rubber-stamp. The residual risk is real and named; that is the point of recording the failure twin rather than only the growth direction. A related failure mode — self-reingestion, where the cycle feeds on its own output and the agent's earlier writing echoes back as if it were observed fact — is treated in ADR-0015, distilled from a production observation in the Contemplative Agent substrate; its defenses are the observed record as the only ground, keeping the self-generated share of promoted artifacts visible (Measure), and the same gate as circuit-breaker.

## How does AKC relate to prior agent-memory and skill-learning work?

AKC's individual operations are not novel in isolation, and ADR-0013 concedes this directly rather than implying invention. Extract→Promote (inducing reusable skills from experience) has named precedent in Voyager (Wang et al., 2023), which maintains an "ever-growing skill library of executable code," and Agent Workflow Memory (Wang et al., 2024), which induces reusable workflows from trajectories. Curate (pruning and refining accumulated memory) is the premise of ReMe (Cao et al., 2025) and LangMem (LangChain, 2025), both continuous procedural-memory refinement loops. Extract / reflection (distilling episodes into durable patterns) traces to Generative Agents (Park et al., 2023) and MemGPT (Packer et al., 2023); CoALA (Sumers et al., 2023) supplies the framework vocabulary, and the *Externalization in LLM Agents* survey (Zhou et al., 2026) maps the field as three coupled forms of externalization — memory, skills, and protocols — coordinated by harness engineering as the unification layer, inside which AKC squarely sits.

AKC's delta is not a new operation; it is where AKC sits on the shared axis those systems define — *how an agent turns its own experience into durable, reusable knowledge* — and it is exactly the three core themes (ADR-0012). **First, a structural human approval gate where the prior art runs autonomously.** Voyager, AWM, ReMe, and LangMem close the loop without a human in it; AKC (ADR-0005) requires explicit human sign-off for every behavior-modifying write — skills, rules, identity — with no auto-approve escape hatch. The prior art optimizes for an unattended loop; AKC optimizes for a human-owned one. **Second, a target of *bidirectional* human-judgment growth where the prior art optimizes the agent or its context.** Every system above measures success on the agent side; AKC's stated target (ADR-0009) is that Curate and Promote sharpen the *human's* judgment too. No system in the memory literature names the human's developing judgment as an output to optimize for. **Third, a framing of the scarce resource as *human attention* where the prior art treats agent capability, context, or information volume as binding.** MemGPT's constraint is the context window; ReMe's and LangMem's is memory consistency; AKC (ADR-0010) names human attention and judgment, which become relatively scarcer as agent capability grows. The memory literature solves information-side scarcity; AKC solves attention-side scarcity; both are valid and bind on different resources. This positioning is orthogonal to ADR-0009's harness positioning: ADR-0009 separates AKC from the harness *below* it, ADR-0013 separates AKC from the memory/skill store it is most often *confused for*. The cited works were identified as prior art for positioning, not consulted during AKC's construction. A second positioning axis — against the software-evolution and alignment literatures (Christiano, Lehman, Perry & Wolf, Snook, Meta-Harness, Agent Drift) — is recorded in ADR-0017, which derives the terms harness alignment and harness drift from those vocabularies rather than coining them fresh.

## How does AKC relate to Anthropic's AI-native SDLC playbook?

They name two different loops, and the 6-stages / 6-phases count match is a coincidence — a stage-to-phase table produces nonsense. The playbook (published 2026-08-21; AKC's correspondence is pinned to the version archived 2026-08-24) names the product loop: a software change travels from intent to production and back, each stage committing an artifact the next stage reads. AKC names the harness loop — its own vocabulary says knowledge cycle — whose object is the configuration that steers the agent, not the product the agent ships. The playbook contains the second loop but leaves it unnamed and scattered across Stages 3–6 (corrections into CLAUDE.md, skills as versioned institutional knowledge, an eval suite that runs on configuration changes, monthly review-policy tuning, dismissed findings tuning detection bands); AKC is that loop made explicit, with named phases, owned assets, and its own cadence. The sharpest trap is the shared stage/phase name Maintain: the playbook's Maintain is production monitoring — the product loop's re-entry point that generates new work — while AKC's Maintain is documentation and artifact hygiene. The gaps run the other way on Research (the playbook has no intake discipline for outside knowledge) and Curate (habit and cadence, but no systematic audit of the accumulated set) — a scale difference, not a defect: the playbook assumes staffed roles that notice what each play surfaces, while AKC is written for the operator running the loop alone (ADR-0010). Two artifact-level correspondences: the playbook's intent.md is an RFC-form proposal record under a newer name (a public rfcs/ directory is a faithful intent home), and its continuous-evals play carries an operator-scale condition — keep the deterministic tier (regression tests over configuration) at every scale, add the LLM-judge tier once the corpus is large enough that its verdicts are worth triaging. Full mapping with dated addenda: [docs/ai-native-sdlc-correspondence.md](docs/ai-native-sdlc-correspondence.md).

## How do the six phases map to their scaffolding skills, and how do the three memory layers map to ADR-0003?

- The relationships described in prose throughout this document are also published as a machine-readable JSON-LD graph at [`graph.jsonld`](graph.jsonld). The graph encodes six core node types (`ResearchLine`, `Phase`, `MemoryLayer`, `ADR`, `Concept`, `EcosystemRepo`) and uses the hub vocabulary's existing edge types only — no new edge types required. Three design choices are load-bearing. First, the six phases are typed as `Phase` instances with an `ordinal` integer (1 = Research through 6 = Maintain), so the cycle's order is structurally enforced rather than asserted in prose. Second, `implements` edges run from each skill EcosystemRepo to its corresponding `Phase` — the current phase-to-skill scaffolding made queryable as triples, a mutable snapshot rather than a fixed bijection (ADR-0019). Most phases have one skill; Curate has four scaffolds (skill-health structural code, skill-stocktake semantic for skills, rules-stocktake semantic for always-loaded rules, agent-stocktake semantic for agent definitions), so "which skill realizes the Curate phase?" returns all four; Maintain has two (context-sync for documentation role coherence, repo-asset-stocktake for non-code asset liveness); and skill-comply (Measure) is flagged as a candidate for substrate absorption. Two repos additionally carry implements edges to Concept nodes rather than Phases — human-gate implements the human approval gate, generation-audit implements scaffold dissolution — recording the concept-level scaffolding with the same mutable-snapshot status. Third, the three `MemoryLayer` `@id`s are shared with the Contemplative Agent graph (same URIs in both files), so an LLM crawling both graphs sees the layers as identical entities — ADR-0003's distillation architecture is the same conceptual structure that contemplative-agent runs on. The four code-LLM layering patterns from ADR-0008 (guard / filter / judge / orchestrator) are encoded as `Concept` instances rather than a new node type — four stable items do not warrant their own type. The ResearchLine `@id` uses the parent Zenodo concept DOI (`10.5281/zenodo.19200726`) per shimo4228 convention — Citation files use the latest versioned DOI, badges and graphs use the concept DOI.

+ The relationships described in prose throughout this document are also published as a machine-readable JSON-LD graph at [`graph.jsonld`](graph.jsonld). The graph encodes six core node types (`ResearchLine`, `Phase`, `MemoryLayer`, `ADR`, `Concept`, `EcosystemRepo`) and uses the hub vocabulary's existing edge types only — no new edge types required. Three design choices are load-bearing. First, the six phases are typed as `Phase` instances with an `ordinal` integer (1 = Research through 6 = Maintain), so the cycle's order is structurally enforced rather than asserted in prose. Second, `implements` edges run from each skill EcosystemRepo to its corresponding `Phase` — the current phase-to-skill scaffolding made queryable as triples, a mutable snapshot rather than a fixed bijection (ADR-0019). The edges cover the skills that have standalone repositories, not every plugin skill. Curate has five scaffolds (skill-health structural code, skill-stocktake semantic for skills, rules-stocktake semantic for always-loaded rules, agent-stocktake semantic for agent definitions, generation-audit for model-generation re-audits), so "which skill realizes the Curate phase?" returns all five; Measure has two (skill-comply, llm-as-judge); Maintain has two (context-sync for documentation role coherence, repo-asset-stocktake for non-code asset liveness); and skill-comply (Measure) is flagged as a candidate for substrate absorption. Several repos also carry implements edges to Concept nodes — human-gate to the human approval gate, generation-audit to scaffold dissolution (alongside its Curate edge), llm-as-judge and jev-skill-router to the judge pattern, herdr-toolkit to the three-role loop — recording the concept-level scaffolding with the same mutable-snapshot status. Third, the three `MemoryLayer` `@id`s are shared with the Contemplative Agent graph (same URIs in both files), so an LLM crawling both graphs sees the layers as identical entities — ADR-0003's distillation architecture is the same conceptual structure that contemplative-agent runs on. The four code-LLM layering patterns from ADR-0008 (guard / filter / judge / orchestrator) are encoded as `Concept` instances rather than a new node type — four stable items do not warrant their own type. The ResearchLine `@id` uses the parent Zenodo concept DOI (`10.5281/zenodo.19200726`) per shimo4228 convention — Citation files use the latest versioned DOI, badges and graphs use the concept DOI.

+ ## What a running AKC looks like

+ AKC began in February 2026 as six skills, one per phase. In daily operation since then, the knowledge the cycle produces has settled into four layers (as of 2026-10), and a decision record names the judgment behind each. The skill links here go to the author's running copies in claude-harness; the plugin copies in the README's phase table are what you install:

+ |---|---|---|---|

+ | **Procedures** | Skills an agent loads on demand: the README's phase table. Scaffolding by design, meant to dissolve once internalized | the README's phase table, for example [harness-boundary](https://github.com/shimo4228/claude-harness/tree/main/skills/harness-boundary) | [ADR-0019](docs/adr/0019-cycle-structure-is-provisional.md), [Scaffold Dissolution](docs/scaffold-dissolution.md) |

+ | **Worldviews** | Small always-loaded rules that set defaults instead of prescribing steps: artifacts are written for the next AI session that reads them; every stored decision names what would expire it | [llm-first-code](https://github.com/shimo4228/claude-harness/blob/main/rules/common/llm-first-code.md), [knowledge-staleness](https://github.com/shimo4228/claude-harness/blob/main/rules/common/knowledge-staleness.md), with [adr-writer](https://github.com/shimo4228/claude-harness/tree/main/skills/adr-writer) requiring a Review-when section in every decision record | [ADR-0025](docs/adr/0025-llm-first-artifact-readability.md), [ADR-0026](docs/adr/0026-expiry-conditioned-knowledge.md) |

+ | **Enforcement** | Machine gates (lint, types, tests, frozen golden outputs) own artifact correctness, so the human eye is never the checker of record | the harness's [hooks](https://github.com/shimo4228/claude-harness/tree/main/hooks), [verify-bootstrap](https://github.com/shimo4228/claude-harness/tree/main/skills/verify-bootstrap), [review-to-lint](https://github.com/shimo4228/claude-harness/tree/main/skills/review-to-lint) | [ADR-0008](docs/adr/0008-code-and-llm-collaboration.md) |

+ | **Attention topology** | The judge/build/human three-role loop: a judge session verifies each task's premise, decides what is worth doing, and dispatches it; fresh build sessions implement; the human sets direction and admits tasks | [task-triage](https://github.com/shimo4228/claude-harness/tree/main/skills/task-triage), dispatching to cloud sessions by default and to local panes via [herdr-toolkit](https://github.com/shimo4228/herdr-toolkit) | [ADR-0024](docs/adr/0024-judge-build-human-three-role-loop.md), [ADR-0028](docs/adr/0028-authority-by-artifact-class-in-the-three-role-loop.md) |

+ The through-line is the human approval gate ([ADR-0005](docs/adr/0005-human-approval-gate.md)): in every layer, a change that shapes future behavior needs a named human sign-off. In the running harness the gate is one always-loaded rule, [boundary.md](https://github.com/shimo4228/claude-harness/blob/main/rules/common/boundary.md), which lists what is handed to the human. Authority is placed by artifact class ([ADR-0028](docs/adr/0028-authority-by-artifact-class-in-the-three-role-loop.md)): changes to rules, skills, identity, ADRs and other documents that describe behavior, the control plane, or the verification machinery wait for the human, while admitted task output merges once a machine gate and the judge's inspection pass. Some skills write before asking. `context-sync` edits existing documentation, ADRs included, and lists the files so the human signs off afterwards by keeping or reverting them. `review-to-lint` thins a reviewer's checklist and `verify-bootstrap` writes a repo's gate config and `verify.sh`, and neither has a confirmation step before writing. The three-role loop is the gate at scale: model judgment is spent to conserve human judgment.

+ ## Positioning

+ Harness engineering improves the scaffold so outputs are correct on the first try; AKC keeps the scaffold aligned with what the operator means as that intent evolves ([ADR-0009](docs/adr/0009-akc-is-a-cycle-not-a-harness.md), [ADR-0017](docs/adr/0017-harness-alignment-and-drift.md)). Its individual operations overlap prior agent-memory work such as Voyager, Agent Workflow Memory, ReMe, and MemGPT; its difference is who owns the loop: a structural human approval gate, two-way judgment growth, and scarcity on the attention side ([ADR-0013](docs/adr/0013-positioning-within-agent-memory-literature.md), [`llms-full.txt`](llms-full.txt)). Against Anthropic's AI-native SDLC playbook (2026-08), AKC is the configuration-side loop the playbook leaves scattered across its stages ([docs/ai-native-sdlc-correspondence.md](docs/ai-native-sdlc-correspondence.md)).

+ ## Origin & Acknowledgments

+ Tatsuya Shimomoto ([@shimo4228](https://github.com/shimo4228)) first proposed and implemented this architecture in February 2026, building on [Everything Claude Code (ECC)](https://github.com/affaan-m/everything-claude-code) by [@affaan-m](https://github.com/affaan-m), the baseline harness used in daily practice. AKC emerged when the author's added skills and rules grew large enough that stale skills, contradictory rules, and drifting documentation became their own maintenance problem. The first five cycle skills were contributed to ECC between February and March 2026; `context-sync` was developed independently.

+ ## What's in this repo

+ - [`docs/adr/`](docs/adr/): the decision records. Gaps at 0001, 0006, and 0007 are permanent; that content moved to Agent Attribution Practice in v2.0.0.

+ - [`graph.jsonld`](graph.jsonld): the canonical concept map. [`llms.txt`](llms.txt) routes; [`llms-full.txt`](llms-full.txt) is the self-contained factual reference, including the design principles.

+ - [`docs/akc-cycle.md`](docs/akc-cycle.md): points to the rules file's two editions (the self-contained one akc-cycle distributes, and the pointer edition the author's harness runs).

+ - [`docs/scaffold-dissolution.md`](docs/scaffold-dissolution.md), [`docs/ai-native-sdlc-correspondence.md`](docs/ai-native-sdlc-correspondence.md), and [`docs/glossary.md`](docs/glossary.md).

+ - [`docs/skills/`](docs/skills/README.md): pointers to the design-pattern skills [when-code-when-llm](https://github.com/shimo4228/when-code-when-llm), [code-and-llm-collaboration](https://github.com/shimo4228/code-and-llm-collaboration), and [signal-first-research](https://github.com/shimo4228/signal-first-research).

+ - Standalone repositories for some of the phase-table skills, synced one way from the same source as the plugin, so between syncs they can trail it; the akc-cycle README's [Single skills](https://github.com/shimo4228/akc-cycle#single-skills) section says which to install together: [search-first](https://github.com/shimo4228/search-first), [learn-eval](https://github.com/shimo4228/learn-eval), [skill-health](https://github.com/shimo4228/skill-health), [skill-stocktake](https://github.com/shimo4228/skill-stocktake), [rules-stocktake](https://github.com/shimo4228/rules-stocktake), [agent-stocktake](https://github.com/shimo4228/agent-stocktake), [rules-distill](https://github.com/shimo4228/rules-distill), [skill-comply](https://github.com/shimo4228/skill-comply), [context-sync](https://github.com/shimo4228/context-sync), [repo-asset-stocktake](https://github.com/shimo4228/repo-asset-stocktake), [generation-audit](https://github.com/shimo4228/generation-audit), [llm-as-judge](https://github.com/shimo4228/llm-as-judge).

+ - [`schemas/`](schemas/): JSON schemas for the episode log and knowledge entries.

+ - [`examples/minimal_harness/`](examples/minimal_harness/): a dependency-free Python demo of the three-layer memory model (raw episodes, knowledge, identity and rules) and its two-stage distill pipeline. Run `python -m examples.minimal_harness.demo` from the repository root: with a deterministic fake LLM and no network, it writes three episodes to a temporary log, distills them into two scored patterns, and stops before the third layer, which needs a human sign-off (ADR-0005). [`examples/constitution_amend/`](examples/constitution_amend/) maps the same cycle onto constitutional values, pointing at the running instance in Contemplative Agent.

+ - [`rfcs/`](rfcs/) and [`docs/plans/`](docs/plans/): the public ledger of open proposals and the working plans, in Japanese; decisions land in ADRs.

## How do I cite AKC?

AKC is cited via its Zenodo DOI `10.5281/zenodo.23238854`. BibTeX entry:

```bibtex

@software{shimomoto2026akc,

author = {Shimomoto, Tatsuya},

title = {Agent Knowledge Cycle (AKC)},

year = {2026},

doi = {10.5281/zenodo.23238854},

url = {https://doi.org/10.5281/zenodo.23238854}

}

```

Plain-text citation: Shimomoto, T. (2026). *Agent Knowledge Cycle (AKC)*. doi:10.5281/zenodo.23238854. If your work builds on the engineering substrate (memory layers, distill pipeline) and reached it via AKC, please additionally cite Contemplative Agent ([github.com/shimo4228/contemplative-agent](https://github.com/shimo4228/contemplative-agent)), which is the prior art AKC's ADR-0002 through ADR-0005 were adapted from and is also the upstream home of the security triplet extracted from AKC in v2.0.0.