Athena-Public grades its own load paths, and seven of eight are prompt-only

Guardrails are hooks in one IDE and instructions in the other seven

This is the paragraph that decides whether the project is honest, and it is worth quoting in substance. Memory files and the session routine are Markdown, so they go wherever you go. Guardrails are different: they run as hooks, hooks are tool-specific, and today they are wired in code for Claude Code. In other tools the same rules exist as instructions the model is asked to follow, not code that stops it. The support table makes the arithmetic plain. Seven of the eight listed targets carry a rules-only marker in the guardrail column. Only Claude Code has hooks at all, and even there the entry reads as clone-only with the installed hook still in progress. The four hooks, configured in `.claude/settings.json`, are a secret scan before file reads and edits, a ruin check before shell commands, a meta-awareness gate on each prompt, and an output check for math leaks, secrets and Python syntax before each turn ends. Three quarters of the safety surface is a request.

Four load paths verified, three in progress, and one target that is not wired up

The same table grades each tool's load path, and the statuses are not uniform. Claude Code, Antigravity, Kilo Code and Roo Code are marked verified. Cursor, Gemini CLI and VS Code with Copilot are marked in progress, each with a named gap: Cursor needs `.cursor/rules/*.mdc` while `athena init --ide cursor` writes `.cursor/rules.md`, Gemini reads `GEMINI.md` or `AGENTS.md`, and VS Code needs `.github/copilot-instructions.md` while the flag writes `.vscode/settings.json`. Codex is the outlier, marked untested, with the entry noting it is an untested target that reads `AGENTS.md`. Codex does not appear in the quickstart's flag list at all, which names seven IDEs against the table's eight. So the gap is not a documentation oversight alone: for one target there is no documented command, and for three more the command writes a file the IDE does not read.

/end writes CANONICAL.md, and the skeleton never mentions it

The workspace skeleton is small and specific:

.context/
├── memory_bank/
│   ├── userContext.md       # who you are and how you work
│   ├── productContext.md    # what you're building, and why
│   ├── activeContext.md     # where you left off: session checkpoints
│   └── systemPatterns.md    # architectures and patterns that keep working
├── memories/session_logs/   # session logs created at /start, finalized at /end
└── project_state.md         # active tasks and milestones

The loop then says `/end` writes the session log, appends a checkpoint to `activeContext.md`, and updates `CANONICAL.md` when confirmed facts change. `CANONICAL.md` is nowhere in that tree, and the layer diagram names canonical facts only as a category under Memory. It is plausibly generated rather than scaffolded, which would make it consistent, but as documented the file the routine maintains most carefully is the one the layout does not describe.

A lightweight install still pulls four cloud SDKs and ONNX Runtime

The quickstart offers two profiles, `pip install -e ".[local]"` described as lightweight and `pip install -e ".[full]"` for cloud sync and reranking. A note then concedes what the lightweight one still costs: the extras are minimal for local use, but the cloud SDKs for Supabase and Anthropic are installed in base dependencies for hybrid search, with full decoupling scheduled for v10.1. The manifest confirms it and goes further. Eleven base dependencies include `supabase>=2.0.0`, `anthropic>=0.40.0` and `google-genai>=1.0.0` as three separate provider clients, alongside `onnxruntime>=1.16.0` as a native runtime, `flashrank` for reranking, `fastmcp`, `diskcache`, `pydantic`, `requests`, `python-dotenv` and `pyyaml`. So the local profile saves on configuration rather than on weight, and the promised decoupling is a dated plan rather than shipped behaviour. The comparison table the project argues from puts the baseline next to two alternatives, marking a bare `CLAUDE.md` or `AGENTS.md` as static instructions that do not build up across sessions, and Cline Memory Bank as in-session prompts that are Cline-centric rather than portable. Both of those baselines are portable in the third column, so the axis Athena claims for itself is the first one, accumulation.

The manifest reads 10.0.2 and the newest tag is v10.0.1

Three version signals disagree slightly, which is normal for an active repository and worth stating rather than glossing. The packaging metadata declares version 10.0.2 while the newest published release is v10.0.1, so the default branch carries a patch version that has never been tagged. The two most recent releases are a day apart, v10.0.0 on 2026-09-27 described as a major architectural sync with a ledger-backed engine, and v10.0.1 on 2026-09-28 adding a deliverable audit mode and multi-agent launcher hardening. The oddity sits one release earlier: v9.9.9 was published on 2026-08-27 but its release name reads Full Synchronized Digital Portfolio Refresh with the date 28 September 2026, a month later than the tag's own date. The last push to the default branch is dated 2026-10-01.

anthropic is a hard dependency and .env.example asks for four keys

The example environment file is short and names two services. For Supabase, taken from the dashboard project settings API page, it lists `NEXT_PUBLIC_SUPABASE_URL`, `SUPABASE_URL` and `SUPABASE_SERVICE_ROLE_KEY`. For embeddings it lists `GOOGLE_API_KEY`, pointing at Google AI Studio. That is the whole file, four variables, and it ends with a pointer to two source files for the full picture, `src/athena/memory/vectors.py` and `src/athena/boot/shutdown.py`. Two things stand out. The Anthropic client is a required dependency and the README names it as a cloud SDK, yet no Anthropic key appears in the example, so an Anthropic-backed path would be configured outside the documented surface. And the service-role key is the Supabase credential that bypasses row-level security, which is a notable thing to see written into an example file even as a placeholder.

robots.txt, a sitemap, a wiki directory and a sandbox Dockerfile

The top level mixes a Python package with a website and a sandbox. Alongside `src/`, `tests/`, `docs/` and `pyproject.toml` there are `robots.txt`, `sitemap.xml`, `.nojekyll`, a `.syncignore`, a `.gitleaksignore`, an `Athena-Public.wiki/` directory, `community/`, a `supabase/` directory, an `athena.yaml` config and a `Dockerfile.sandbox`. The `examples/` directory carries roughly twenty-five entries, from concept and pattern write-ups through `hooks/`, `skills/`, `templates/` and `workflows/`, and it includes a committed `logs/` directory and two demo images. Underneath all of that the routine is deliberately cheap: `/start` loads about two thousand tokens of who you are plus your last checkpoint, and skipping it in favour of just `/end` costs around five hundred. The memory design itself is credited as building on the open architecture introduced by Cline Memory Bank, adding multi-IDE portability, session lifecycle automation and canonical fact tracking to it, and the quickstart's own flow ends by asking you to run `athena doctor` and expect zero failures, which is the cheapest way to find out whether the wiring suits the machine you are on.

Editorial conclusion

Use Athena-Public when you move between coding agents and want one on-disk memory that follows you, because the Markdown memory bank and the `/start` and `/end` routine genuinely are portable and that part of the pitch holds. Do not adopt it for the guardrails. The documentation is admirably clear that hooks are wired for Claude Code alone and that in the other seven targets the same rules are instructions the model is asked to follow, so treat the safety story as prompt-level except where the table says otherwise. Before you install, note that the lightweight extra still brings Supabase, Anthropic, Google Gen AI and ONNX Runtime into the required set, that the manifest reads 10.0.2 while the newest tag is v10.0.1, and that a Supabase service-role key is one of the four variables the example environment file asks for.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. winstonkoh87/Athena-Public on GitHub