akm-cli 0.9.30 → 0.10.261001-beta

package/docs/posts/akm-command-tour.md

@@ -0,0 +1,495 @@
+---
+title: 'What akm Actually Does: A Command-by-Command Tour'
+cover_image: 'https://raw.githubusercontent.com/itlackey/akm/main/docs/posts/akm-logo-sized.webp'
+series: akm-basics
+description: 'A high-level guide to what akm is for, what each command does, and how teams use the CLI in real workflows.'
+tags:
+  - ai
+  - agents
+  - cli
+  - productivity
+published: true
+id: 3629633
+date: '2026-05-07T23:51:17Z'
+---
+
+> This is a dated article from AKM's publishing archive. For current product behavior, see the
+> [documentation index](https://github.com/itlackey/akm/blob/main/docs/README.md).
+
+If you've looked at `akm` for the first time and thought "this seems useful, but what do all these commands actually *do*?" this post is for you.
+
+At a high level, `akm` is a package manager for AI agent capabilities. It gives your agents a searchable library of scripts, skills, commands, agents, knowledge docs, workflows, environment groups, wikis, lessons, and memories. Instead of dumping everything into a giant system prompt, you let the agent discover what it needs with search, then load the right asset at the right time.
+
+That's the big idea. The practical question is how the command surface fits together in day-to-day work.
+
+This post walks through the CLI by job-to-be-done, with real examples of when you'd use each command.
+
+> This command-family framing reflects `akm` v0.9.0.
+
+## The Short Version
+
+You can think about `akm` in seven layers:
+
+1. **Set up the workspace** — `setup`, `init`, `config`, `info`, `index`
+2. **Connect sources and discover new ones** — `add`, `list`, `update`, `remove`, `clone`, `sync`, `registry`
+3. **Find and inspect assets** — `curate`, `search`, `show`
+4. **Build local knowledge and operational context** — `remember`, `import`, LLM wiki bundles, `env`
+5. **Run repeatable procedures** — `workflow`
+6. **Continuously improve the stash** — `feedback`, `history`, `log`, `improve`, `propose`, `proposal`
+7. **Operate the CLI comfortably** — `help`, `hints`, `completions`, `upgrade`
+
+If you only remember one mental model, make it this:
+
+- `akm add` tells akm where content lives
+- `akm index` makes that content searchable
+- `akm curate` gives the best first shortlist for a request
+- `akm search` is for deeper discovery when you need more than the curated list
+- `akm show` loads the full thing
+
+Everything else supports one of those steps.
+
+## What akm Is Really For
+
+Most teams already have agent assets. They're just scattered.
+
+- Claude Code skills in one folder
+- OpenCode commands in another
+- project notes in random markdown files
+- internal runbooks in a docs repo
+- half-remembered lessons buried in old chats
+
+`akm` turns that mess into a searchable, reusable library.
+
+For example, imagine a team that ships a web app every week. They might use `akm` to unify:
+
+- local review and release skills
+- a shared Git repo of deployment workflows
+- internal docs imported as knowledge
+- a production environment group that exposes secret *keys* without leaking values
+- memories like "staging deploys require VPN"
+
+Now an agent can start with a curated shortlist for "ship release", load the release workflow, check the deployment environment group, read the runbook section it needs, and only fall back to broader search if it needs more options.
+
+## 1. First-Run and Environment Commands
+
+### `akm setup`
+
+Use this when you want the guided on-ramp.
+
+```sh
+akm setup
+```
+
+Real-world use: you just installed `akm` on a new laptop and want the wizard to create the working stash, configure providers, and build the first index without editing config by hand.
+
+### `akm init`
+
+Use this when you want to skip the wizard and just create the working stash.
+
+```sh
+akm init --dir ~/akm  # doclint:ignore (historical — pre-0.9.0 command spelling)
+```
+
+Real-world use: you're scripting environment bootstrap for a devcontainer or CI image and want a known stash location without interactive prompts.
+
+### `akm config`
+
+Use this to inspect or change settings.
+
+```sh
+akm config get output.format
+akm config set output.detail full
+akm info
+```
+
+Real-world use: your agent prefers text output in one repo and JSON in another, or you want to set a default write target for memories and imports.
+
+### `akm info`
+
+Use this as the health check.
+
+```sh
+akm info
+```
+
+Real-world use: after setup, you want to confirm the version, active sources, registries, and whether semantic search is actually ready.
+
+### `akm index`
+
+Use this whenever content changed and you want search to reflect it.
+
+```sh
+akm index
+akm index --full
+```
+
+Real-world use: you added a GitHub stash, imported some docs, and created two memories. `akm index` refreshes the local search database so the agent can discover them.
+
+## 2. Source and Registry Commands
+
+These commands answer two related questions:
+
+- where should akm look for assets right now?
+- where can I discover more stashes later?
+
+### `akm add`
+
+This is how you register a source.
+
+```sh
+akm add ~/.claude/skills  # doclint:ignore (historical — pre-0.9.0 command spelling)
+akm add github:your-org/team-agent-toolkit  # doclint:ignore (historical — pre-0.9.0 command spelling)
+akm add @scope/platform-stash  # doclint:ignore (historical — pre-0.9.0 command spelling)
+akm add https://docs.example.com --name public-docs  # doclint:ignore (historical — pre-0.9.0 command spelling)
+```
+
+Real-world use:
+
+- point `akm` at your existing Claude Code skills
+- pull in a shared team stash from GitHub
+- install an npm-published stash
+- crawl a documentation site as searchable knowledge
+
+### `akm list`
+
+Shows what sources are already connected.
+
+```sh
+akm list  # doclint:ignore (historical — pre-0.9.0 command spelling)
+```
+
+Real-world use: you're debugging why a search result isn't appearing and want to verify whether the expected repo or local directory is even registered.
+
+### `akm update`
+
+Refreshes managed sources.
+
+```sh
+akm update --all  # doclint:ignore (historical — pre-0.9.0 command spelling)
+```
+
+Real-world use: your platform team shipped an updated deployment stash and everyone pulls the latest version before a release.
+
+### `akm remove`
+
+Disconnect a source you no longer want indexed.
+
+```sh
+akm remove public-docs  # doclint:ignore (historical — pre-0.9.0 command spelling)
+```
+
+Real-world use: a website source became noisy or outdated and you want it out of search results.
+
+### `akm clone`
+
+Copies a single asset into your working stash or another directory so you can edit it locally.
+
+```sh
+akm clone skills/code-review
+akm clone "npm:@scope/platform-stash//workflows/ship-release"
+```
+
+Real-world use: you find a good community skill, clone it into your local stash, and tailor it for your team's code review conventions.
+
+### `akm sync`
+
+Commit local stash changes, and optionally push if the source is writable.
+
+```sh
+akm sync -m "Tighten release workflow"
+```
+
+Real-world use: your team keeps its shared stash in Git. After improving a workflow and an environment group, `akm sync` records the change like normal code.
+
+### `akm registry`
+
+Use registries to discover new stashes you have not installed yet.
+
+```sh
+akm search "code review" --from registry
+akm registry add https://example.com/registry/index.json --name team
+```
+
+Real-world use: platform engineering publishes an internal stash registry, and teams browse it the same way they'd browse a package registry.
+
+## 3. Discovery Commands
+
+This is the heart of the product.
+
+### `akm curate`
+
+Start here for a request or prompt. `curate` is the preferred first stop because it returns a tighter, more task-ready shortlist.
+
+```sh
+akm curate "review a large pull request"
+akm curate "ship a bun release"
+```
+
+Real-world use: the agent needs a deploy workflow, a release checklist, or a review skill and wants the best few candidates first instead of a broad result set.
+
+### `akm search`
+
+Use this when you want deeper discovery beyond the curated shortlist.
+
+```sh
+akm search "review a large pull request"
+akm search "kubernetes deploy" --type workflow
+```
+
+Real-world use: `curate` gave you a solid starting point, but now you want to dig wider, inspect additional assets, or explore the long tail of relevant results.
+
+### `akm show`
+
+Load the full content of a specific asset.
+
+```sh
+akm show skills/code-review
+akm show workflows/ship-release
+akm show knowledge/incident-runbook#rollback
+```
+
+Real-world use: `curate` or `search` identifies the right asset; `show` gives the agent the actual instructions, prompt template, workflow steps, or document section it needs to act.
+
+## 4. Local Knowledge and Operational Context
+
+This is the part of `akm` that turns a stash into living local context instead of a static pile of files.
+
+Some commands capture what your team knows. Others make that knowledge safer or more structured. They belong together because they all define the working context your agent can rely on later.
+
+### `akm remember`
+
+Write a memory.
+
+```sh
+akm remember "Staging deploys require VPN access" --tag ops --tag deploy
+```
+
+Real-world use: after an incident or a successful fix, you capture the lesson in a searchable format so the next agent run doesn't rediscover it the hard way.
+
+### `akm import`
+
+Bring a document into the stash as knowledge.
+
+```sh
+akm import ./docs/release-checklist.md
+akm import https://example.com/internal-guide/auth
+```
+
+Real-world use: you have a good architecture note or ops runbook outside the stash and want it indexed alongside everything else.
+
+### LLM wikis
+
+Use an LLM wiki for a long-lived, agent-maintained knowledge base. As of 0.9.0 a wiki isn't a separate command family — it's a **bundle format**: a directory with a `schema.md` rulebook and a `pages/` directory is recognized and indexed automatically the next time you run `akm index`.
+
+```sh
+akm index
+akm search "architecture" --type knowledge
+akm show research-wiki//pages/attention
+akm lint
+```
+
+Real-world use: your team wants a research or architecture wiki with raw sources, curated pages, and deterministic linting instead of ad hoc markdown sprawl. Page writes go through the agent's own file tools (akm's job is recognition and search, not authoring); see the [LLM Wikis guide](../guides/wikis.md) for the directory layout.
+
+Wiki pages belong with local knowledge, not off to the side. It's the shape you reach for when a single imported doc or memory is not enough and you need a maintained body of team knowledge, discovered through the same `akm search`/`akm show` surface as everything else.
+
+### `akm env`
+
+Use environment groups when the agent needs operational context about secrets without seeing the secret values.
+
+```sh
+akm show env/production
+akm env run production -- env
+```
+
+Real-world use: a deploy workflow needs `DATABASE_URL` and `DEPLOY_TOKEN`. The agent can verify the keys are present, then load the environment only at execution time.
+
+Environment groups fit here because they are part of the local operating context. They tell the agent what environment shape exists and let commands run safely without exposing secret values in the chat transcript.
+
+## 5. Procedure Commands
+
+Once you have the right knowledge and context, the next problem is execution across time.
+
+### `akm workflow`
+
+Use workflows for repeatable, resumable procedures.
+
+```sh
+akm workflow start workflow:ship-release --params '{"version":"2.4.0"}' # doclint:ignore (historical workflow lifecycle removed in 0.9)
+akm workflow next workflow:ship-release # doclint:ignore (historical workflow lifecycle removed in 0.9)
+akm workflow complete run-123 --step validate --notes "Version and branch confirmed" # doclint:ignore (historical workflow lifecycle removed in 0.9)
+```
+
+Real-world use: shipping a release, rotating secrets, onboarding a new service, or any other multi-step process that should survive across sessions instead of living only in chat history.
+
+## 6. Continuous Improvement Commands
+
+This is the loop that makes `akm` better over time.
+
+The flow is simple:
+
+1. an agent uses an asset
+2. you record whether it helped with `feedback`
+3. you inspect what happened with `history` or `log`
+4. you ask for improvements with `improve` or `propose`
+5. you review the result with `proposal`
+6. you turn recurring feedback into reusable lessons with `improve`
+
+These commands should be thought about as one system, not as isolated features.
+
+### `akm feedback`
+
+Record whether an asset helped.
+
+```sh
+akm feedback workflows/ship-release --positive
+akm feedback skills/legacy-deploy --negative --reason "Outdated after platform migration"
+```
+
+Real-world use: over time, assets that consistently help rise in ranking and stale ones become easier to spot.
+
+### `akm log`
+
+Read the append-only realtime event stream — inspect the recorded state
+changes for an asset or the whole stash.
+
+```sh
+akm log --ref workflow:ship-release
+```
+
+Real-world use: you want to know whether a workflow was searched, shown, or downvoted recently while cleaning up a team's stash, or another process is watching `akm` activity and reacting when new feedback, imports, or proposals land (poll `--since '@offset:<id>'` to resume without duplicates).
+
+### `akm improve`
+
+Ask an external agent to improve an existing asset.
+
+```sh
+akm improve skills/code-review --task "make this stricter about test coverage"
+```
+
+Real-world use: you have a decent review skill, but you want an agent to improve it based on how it's actually being used.
+
+### `akm proposal new`
+
+Generate a brand-new asset proposal.
+
+```sh
+akm proposal new workflow incident-rollback --task "Rollback procedure for failed production deploys"
+```
+
+Real-world use: repeated gaps in your stash show up in `history` and `log`, so you create a first draft for the missing workflow or skill.
+
+### Proposal Queue
+
+Review, diff, accept, or reject queued proposals.
+
+```sh
+akm proposal list
+akm proposal diff 42
+akm proposal accept 42
+```
+
+Real-world use: keep human review in the loop before generated assets become part of the live stash.
+
+## 7. Operator Ergonomics
+
+These are the commands that make the CLI easier to live with day to day.
+
+### `akm help`
+
+Focused help topics, especially migrations.
+
+```sh
+akm help migrate latest
+```
+
+Real-world use: you upgraded `akm` and want the release-specific migration notes without leaving the terminal.
+
+### `akm hints`
+
+Print instructions you can drop into `AGENTS.md` or `CLAUDE.md`.
+
+```sh
+akm hints
+```
+
+Real-world use: you want every project to tell its coding agent how to use the local `akm` installation.
+
+### `akm completions`
+
+Generate or install shell completion.
+
+```sh
+akm completions --install
+```
+
+Real-world use: you use `akm` daily and want tab completion for commands and flags.
+
+### `akm upgrade`
+
+Upgrade the `akm` binary itself.
+
+```sh
+akm upgrade --check
+```
+
+Real-world use: you installed the standalone binary and want to see whether a newer release is available.
+
+## 8. The Commands People Use Most
+
+In practice, most teams live in a much smaller subset of the CLI:
+
+```sh
+akm setup
+akm add ...  # doclint:ignore (historical — pre-0.9.0 command spelling)
+akm index
+akm curate "..."
+akm show <ref>
+akm remember "..."
+akm feedback <ref> --positive
+```
+
+If your use case grows, the rest of the command surface is there:
+
+- `workflow` when procedures need state
+- an LLM wiki bundle (`schema.md` + `pages/`) when local knowledge needs structure
+- `env` when local operational context includes secrets
+- `registry` when discovery goes beyond your local stash
+- `feedback` / `history` / `log` / `improve` / `propose` / `proposal` when you want a real improvement loop
+
+## A Simple End-to-End Example
+
+Let's say your team is onboarding a new service.
+
+1. Run `akm add github:your-org/platform-stash`
+2. Run `akm add ./docs/runbooks`
+3. Run `akm index`
+4. Start with `akm curate "onboard a new service"`
+5. Open the best match with `akm show workflows/service-onboarding`
+6. Check required environment keys with `akm show env/staging`
+7. Add the final onboarding notes as an agent-authored page under the team wiki bundle's `pages/`, then `akm index` to pick it up
+8. Capture a new lesson with `akm remember "Service onboarding requires DNS approval from ops" --tag ops`
+9. Record whether the workflow helped with `akm feedback workflows/service-onboarding --positive`
+10. If the workflow was weak, run `akm improve workflows/service-onboarding --task "improve this after the latest run"`
+
+That's `akm` in a nutshell: connect sources, index them, find what matters, load only what you need, and keep the library getting better.
+
+## Final Takeaway
+
+`akm` is not trying to replace your coding assistant. It's the layer that makes your assistant's skills, docs, procedures, and institutional memory manageable at scale.
+
+If you want the one-sentence version:
+
+> `akm` is the command line system that helps agents discover, load, share, improve, and safely reuse the capabilities they need to do real work.
+
+And if you're wondering where to start, start here:
+
+```sh
+akm setup
+akm add ~/.claude/skills  # doclint:ignore (historical — pre-0.9.0 command spelling)
+akm add github:your-org/team-agent-toolkit  # doclint:ignore (historical — pre-0.9.0 command spelling)
+akm index
+akm curate "code review"
+akm show skills/code-review
+```
+
+That gets you from "I installed it" to "my agent can actually use it" in a few minutes.

package/docs/posts/belief-aware-memory-12.md

@@ -0,0 +1,139 @@
+---
+title: 'Belief-Aware Memory: Teaching Your Agent When Not to Write'
+cover_image: 'https://raw.githubusercontent.com/itlackey/akm/main/docs/posts/akm-logo-sized.webp'
+series: akm-knowledge
+description: 'akm 0.8.0 introduces belief-aware memory — captureMode (hot/background) and beliefState frontmatter that tells the improve loop what it is and is not allowed to overwrite.'
+tags:
+  - ai
+  - agents
+  - memory
+  - cli
+published: true
+id: 3814544
+date: '2026-06-04T00:32:02Z'
+---
+
+> This is a dated article from AKM's publishing archive. For current product behavior, see the
+> [documentation index](https://github.com/itlackey/akm/blob/main/docs/README.md).
+
+A self-improving memory loop sounds like a clear win until you watch it rewrite something correct with something outdated. The agent remembered a fact. You verified it. A later consolidation pass ran against a stale context window, decided the memory was imprecise, and replaced it with a weaker version. The original was better. You lost ground.
+
+This is the failure mode that belief-aware memory was built to prevent. Not "agents write wrong things" — that's a model quality problem. The specific failure is: the improve loop, running unsupervised, overwrites correct content it should have left alone. A loop that can degrade its own best work is worse than no loop at all.
+
+akm 0.8.0 ships `captureMode` and `beliefState` as first-class frontmatter fields on memory assets. Together they tell the consolidation pass what each memory is, what the agent believes about it, and whether it is eligible to be rewritten.
+
+## The Two Capture Modes
+
+Every memory asset now carries a `captureMode` field. It has two values.
+
+`hot` means the memory was written or explicitly confirmed by a human. The improve loop treats hot memories as read-only. No consolidation plan, no merge proposal, no rewrite. If every memory in a chunk is `captureMode: hot`, the consolidation pass skips the LLM call for that chunk entirely — the chunk is counted as `judgedNoAction` before a single token is spent. This is the all-hot chunk early-exit.
+
+`background` means the memory was generated by an agent — promoted during a prior consolidation run, written by an inference pass, produced by `akm remember` without explicit human review. Background memories are eligible for improvement. The consolidation pass can propose merges, rewrites, deletions, or upgrades.
+
+When no `captureMode` is set, the memory is treated as eligible for consolidation. Memories that existed before 0.8.0 are treated this way on first encounter.
+
+```yaml
+---
+captureMode: hot
+beliefState: asserted
+description: Primary LM Studio endpoint moved to Shredder (192.168.0.99:1234)
+---
+```
+
+```yaml
+---
+captureMode: background
+beliefState: active
+description: Approximate token throughput for qwen3.5-9b on RTX 4060 Ti
+---
+```
+
+The distinction matters most for memories that are both accurate and stable: architectural decisions, confirmed configuration facts, verified benchmarks. You write them once, mark them hot, and the improve loop stops touching them.
+
+## The Belief States
+
+`beliefState` describes the agent's current belief about the memory's accuracy. The field has five non-archived values.
+
+`active` is the default when no `beliefState` is set. The memory is currently believed to be true. The consolidation pass treats it normally according to its `captureMode`.
+
+`asserted` is the human-authority variant of `active`. The improve loop sets this when you use `akm remember` explicitly. Like `active`, the consolidation pass treats it as eligible based on `captureMode` — but `asserted` is never automatically downgraded to `active` during consolidation. It carries a stronger signal that a human touched this memory directly.
+
+`deprecated` means the memory has been superseded. The content is no longer the current best representation, but it is not wrong — it describes something that was true and has since evolved. Deprecated memories are frozen historical state — the consolidation pass will not refresh them to `active`, but they are candidates for merge into a more current memory.
+
+`superseded` is the system-assigned equivalent of deprecated. The improve loop writes this when it determines a memory has been replaced by a newer one. Unlike `deprecated`, `superseded` can be refreshed if the superseding memory is later retracted.
+
+`contradicted` means the memory is known to be wrong. It conflicts with something else in the stash that the agent now believes more strongly. A contradicted memory is never promoted, never merged into a primary, and is queued for deletion on the next consolidation pass that touches it.
+
+```yaml
+---
+captureMode: background
+beliefState: contradicted
+contradictedBy:
+  - memory:lm-studio-server-topology
+description: Old belief that Don was the consolidation LLM endpoint
+---
+```
+
+The `contradictedBy` field is an array of refs — the memories that supersede this one. It chains revisions explicitly. You can read the chain backward: follow each `contradictedBy` ref to find the current belief. The `beliefState` field is indexed as a frontmatter tag, so `akm search "beliefState:contradicted"` or `akm search "beliefState:deprecated"` surfaces everything the agent currently believes is wrong or outdated, which is useful for auditing stale content before a long session.
+
+## What the Improve Loop Actually Checks
+
+When `akm improve` starts a consolidation chunk, it evaluates `captureMode` before making any LLM call. The sequence is:
+
+1. Load the memory pool for the chunk.
+2. Check `captureMode` for every memory in the chunk.
+3. If all memories are `hot`, record the chunk as `judgedNoAction` and skip to the next chunk. No model call.
+4. If any memory is `background` (or has no `captureMode` set), proceed to the LLM consolidation prompt — but pass the belief state metadata alongside each memory so the model knows what it is working with.
+5. The model sees `beliefState: contradicted` on a memory and knows not to use it as a merge primary. It sees `beliefState: deprecated` and treats the memory as a merge candidate rather than a standalone to preserve.
+
+The early-exit on all-hot chunks is a real cost reduction in practice. A stash where the majority of permanently-settled memories are marked hot will skip a significant fraction of chunks without touching the model at all. Those skipped chunks still count in the run's telemetry — the `judgedNoAction` counter — so `akm health` can show you the proportion of work that was bypassed via belief state rather than processed.
+
+## Enabling Belief-Aware Memory
+
+Belief-aware memory is active by default in 0.8.0. For most setups, nothing changes on upgrade. Existing memories without a `captureMode` field are treated as eligible for consolidation, and existing memories without a `beliefState` field resolve to `active` — both match prior behavior.
+
+The `memory.belief_aware` configuration flag (enabled by default; not surfaced in `akm config list` — check release notes if you need to toggle it) (documented in the release notes) gates the pre-write validation path. Leaving it on is the right default. The validation overhead is negligible. The protection against overwriting confirmed content is the point.
+
+## The Workflow in Practice
+
+The intended workflow is straightforward. Run `akm improve` or `akm remember` normally. When the improve loop promotes a memory that you verify and want to lock, open the asset and set `captureMode: hot`. That is the only required human action.
+
+```sh
+# Review a promoted memory
+akm show memory:lm-studio-server-topology
+
+# Lock it against future rewrites
+# Edit the frontmatter: captureMode: hot
+```
+
+When something in the stash becomes wrong — you find a configuration fact that has changed, a benchmark that does not reflect the current hardware — mark it contradicted and point it at the memory that replaced it:
+
+```yaml
+---
+captureMode: background
+beliefState: contradicted
+contradictedBy:
+  - memory:shredder-throughput-2026-05
+description: Initial throughput estimate for Shredder before thermal tuning
+---
+```
+
+The contradicted memory stays in the stash until the consolidation pass processes it. It does not disappear immediately. That is intentional — the chain of belief updates is itself a record of how your agent's understanding evolved. You can review it, audit it, and delete it explicitly when you are satisfied the current belief is stable.
+
+For deprecated memories, the same pattern applies, but with a lighter touch. A deprecated memory is not wrong — it is outdated. The consolidation pass will eventually merge it into something more current. You can accelerate this by pointing the `contradictedBy` field at the successor, but it is not required.
+
+## What This Protects Against
+
+The improve loop is powerful because it runs continuously and without supervision. That is also the source of the failure mode. An unsupervised loop that can propose changes to anything in the stash will, given enough time and enough edge cases, propose a change to something it should not touch.
+
+Hot memories are immune. They require no ongoing maintenance. They do not need to be defended against the loop because the loop is not allowed to reach them.
+
+Background memories with `beliefState: active` or `asserted` are in normal rotation. The loop can improve them. That is the intended behavior — background memories accumulate in agent sessions and benefit from periodic consolidation.
+
+The contradicted and deprecated states give the loop a way to reason about quality without conflating "eligible for improvement" with "currently correct." A background, active memory is eligible and believed correct. A background, contradicted memory is eligible and believed wrong — the right action is deletion or absorption, not refinement.
+
+The combination — two capture modes, five belief states, and an explicit contradiction chain — gives you fine-grained control over what the loop does. The loop becomes an asset rather than a liability when it has enough information to distinguish what it should improve from what it should leave alone.
+
+---
+
+Belief-aware memory is part of akm 0.8.0. The full field reference is in [configuration reference](../reference/configuration.md). The improve pipeline and consolidation pass behavior are covered in the [improve pipeline debugging post](https://dev.to/itlackey/your-agent-has-a-memory-that-runs-while-you-sleep-20oh) and the [0.8.0 release notes](https://dev.to/itlackey/akm-080-cli-redesign-task-assets-and-belief-aware-memory-335a). For a walkthrough of the improve loop setup and scheduling, see [The Improve Loop: Continuous Memory Curation](https://dev.to/itlackey/the-improvement-loop-how-akm-keeps-your-agent-sharp-2d4d).