Add Memory Kind
EverMind-AI/EverOS
Walks through adding a new persisted memory kind to EverOS: choose storage among Markdown, SQLite and LanceDB, pick a Markdown strategy, then wire schemas, repos and writers.
Claude Science's own session database schema and SDK surface for introspection via host.query().
$ npx skills add JimLiu/science-skills --skill self-awareness -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install JimLiu/science-skills self-awareness --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/JimLiu/science-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/self-awareness .claude/skills/self-awareness && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "self-awareness" agent skill from https://github.com/JimLiu/science-skills/tree/main/skills/self-awareness into .claude/skills/self-awareness/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "self-awareness", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/JimLiu/science-skills/tree/main/skills/self-awarenessType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add JimLiu/science-skills --skill self-awareness -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install JimLiu/science-skills self-awareness --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/JimLiu/science-skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/self-awareness .agents/skills/self-awareness && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "self-awareness" agent skill from https://github.com/JimLiu/science-skills/tree/main/skills/self-awareness into .agents/skills/self-awareness/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "self-awareness", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add JimLiu/science-skills --skill self-awareness -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install JimLiu/science-skills self-awareness --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/JimLiu/science-skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/self-awareness .cursor/skills/self-awareness && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "self-awareness" agent skill from https://github.com/JimLiu/science-skills/tree/main/skills/self-awareness into .cursor/skills/self-awareness/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "self-awareness", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/JimLiu/science-skills.git --path skills/self-awareness--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add JimLiu/science-skills --skill self-awareness -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install JimLiu/science-skills self-awareness --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/JimLiu/science-skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/self-awareness .gemini/skills/self-awareness && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "self-awareness" agent skill from https://github.com/JimLiu/science-skills/tree/main/skills/self-awareness into .gemini/skills/self-awareness/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "self-awareness", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install JimLiu/science-skills self-awarenessInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add JimLiu/science-skills --skill self-awareness -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/JimLiu/science-skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/self-awareness .github/skills/self-awareness && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "self-awareness" agent skill from https://github.com/JimLiu/science-skills/tree/main/skills/self-awareness into .github/skills/self-awareness/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "self-awareness", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add JimLiu/science-skills --skill self-awareness -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install JimLiu/science-skills self-awareness --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/JimLiu/science-skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/self-awareness .opencode/skills/self-awareness && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "self-awareness" agent skill from https://github.com/JimLiu/science-skills/tree/main/skills/self-awareness into .opencode/skills/self-awareness/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "self-awareness", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
self-awarenessClaude Science's own session database schema and SDK surface for introspection via host.query().
Self Awareness is an agent skill from JimLiu/science-skills. Claude Science's own session database schema and SDK surface for introspection via host.query(). Load this when you need to query your own conversation history, token usage, cost accounting, execution log, or artifact metadata beyond what host.frames()/host.artifacts() provide — e.g. "how many tokens has this session used", "what was my last tool call", "list every file I've written", "where are messages stored", "what tables can I query", "inspect frames.contextdata", or any time you're about to PRAGMA-probe the…
Its SKILL.md is about 3.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
It sits in Databases, covering Database schema design and Accounting and bookkeeping. It works with SQLite. The licence is Apache-2.0.
Read from SKILL.md and the folder at commit fb309c3. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md (its code samples are python).
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Self Awareness loads about 3.4k tokens when it runs. Until then it costs about 146 tokens; SKILL.md has 1,087 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from JimLiu/science-skills at commit fb309c3, republished under its Apache-2.0 licence (© JimLiu). 1,087 words, ~3,397 tokens.
.claude/skills/self-awareness/SKILL.md (or your agent's skills folder).host.query(sql, params=[], limit=None, df=False) runs read-only SQLite
against Claude Science's own metadata DB. It is only available via the repl
tool (not python/r). Results are automatically scoped to the current
project, so SELECT * FROM frames returns only frames in this project. The
repl tool is stdlib-only — df=True returns the raw dict there (use
json.dump(..., open("handoff/q.json","w")) and load in a python cell if
you want pandas).
created_at > strftime('%s','now','-1 day')*1000). Booleans are 0/1.
JSON columns are TEXT — use json_extract(col, '$.key'). Recursive CTEs OK.SELECT / WITH / PRAGMA / EXPLAIN only; one statement per call;
? placeholders with params=[...].memories to the current user) via CTEs that shadow the
real tables — session_claims, verification_checks, and poller_lease
are unscoped. You therefore cannot use main.table / temp.table —
schema-qualified names are rejected.limit=1000); cells >2000 chars are
clipped in place with a …[+N chars] marker; total serialized output
capped at ~100k chars (truncated=True, truncation_reason="total_size_cap"
— narrow your columns). 5-second timeout.host.query("PRAGMA table_info(frames)") or
host.query("SELECT name, sql FROM sqlite_master WHERE type='table'").frames — one row per agent frame (a root conversation or a delegated
sub-agent). The frame you are running in now is one of these rows.
Key columns: id, parent_frame_id, root_frame_id, agent_name,
delegate_name, status (processing/completed/failed/cancelled/
awaiting_user_response/awaiting_plan_approval), model, effort, input_tokens,
output_tokens, cache_read_tokens, cache_write_tokens, total_cost,
task_summary, status_description, conversation_type, name,
project_id, created_at, updated_at, completed_at,
last_user_message_at, is_hidden.
JSON columns: input_data (what started the frame), output_data
(json_extract(output_data,'$.response') is the final response text),
context_data (the full serialized runner state — see below),
mentioned_artifact_ids, specialists_used.
context_data is large. It holds the entire runner state under
underscore-prefixed keys — notably $._messages (the full conversation
array), $._input_tokens / $._output_tokens / $._total_cost (same values
as the top-level columns), $._running_children, $._plan_json,
$._compaction_count, $._tool_id_to_frame_id. Selecting it raw will hit
the cell cap; use json_extract/json_array_length to read specific keys.
For the messages themselves, prefer host.frames(frame_id=...) which
paginates — _messages via SQL will truncate on any non-trivial session.
compaction_archives — pre-compaction message snapshots.
frame_id, compaction_index, message_count, token_count, summary,
messages (JSON array), created_at. When a frame's _compaction_count > 0,
the original messages that were summarized live here.
notifications — parent↔child messages. sender_frame_id,
recipient_frame_id, root_frame_id, notification_type, payload (JSON),
read_at, created_at.
projects — id (proj_*, not a UUID), name, description,
context, user_id, uploads_frame_id, memory_enabled, created_at,
updated_at.
notes — user annotations. project_id, target_type,
target_frame_id, target_message_index, target_artifact_id, content.
artifacts — one row per file. id, project_id, root_frame_id,
frame_id, filename, latest_version_id, is_user_upload, is_ephemeral,
folder_id, sort_order, priority, created_at.
artifact_versions — one row per saved revision. id, artifact_id,
version_number, frame_id, content_type, size_bytes, checksum,
storage_path, extracted_code, code_description, language,
agent_name, is_intermediate, is_checkpoint, parent_version_id,
producing_cell_id (→ execution_log.id), created_at. JSON:
lineage_messages, dependency_mappings, environment_snapshot,
annotations, cell_sources. Join artifacts.latest_version_id = artifact_versions.id for size/type.
artifact_dependencies — DAG edges. artifact_version_id,
depends_on_version_id, reference_name.
artifact_folders — id, project_id, parent_id, name,
root_frame_id, is_conversation_folder, is_user_uploads_folder,
sort_order.
content_snapshots — content-addressed dedup store. hash, content,
size_bytes. Referenced by artifact_versions.lineage_snapshot_hash /
env_snapshot_hash.
execution_log — one row per python/r/bash/repl cell, in
order. id, frame_id, cell_index (monotonic), kernel_id, kernel_kind
(analysis/operon), conda_env,
language, source (exact submitted
code), stdout, stderr, exit_status (ok/error/kernel_died/
cancelled), error_lineno, files_written (JSON [{path, sha256}]),
created_at. This is the ground-truth record of everything you've run.
host_call_log — one row per host.* SDK call made inside a cell.
id, execution_log_id (→ execution_log.id), seq, method
(query_db/llm/mcp/list_frames/…), args_json, derivable,
data_inline, data_ref, error, bytes, created_at. Ordered by
(execution_log_id, seq).
compute_usage — remote compute jobs. job_id, environment,
tier_type (gpu/cpu), provider, frame_id, project_id, started_at,
ended_at (null ⇒ running), expires_at, state, remote_workdir,
submit_cell_id. JSON: output_specs, remote_handle.
session_claims — falsifiable claims extracted for verification.
root_frame_id, frame_id, step_id, claim_text, entities (JSON),
source (agent/haiku_extracted).
verification_checks — reviewer verdicts. root_frame_id,
artifact_version_id, claim_id, claim, verdict
(pass/warn/fail/inconclusive), severity, evidence, rebuttal,
reviewer_model, reviewer_frame_id, source_ref (JSON), status
(open/resolved/unaddressed), reflag_count.
memories — durable beliefs (user-scoped; may be absent on some builds).
id (mem_*), body, subject_project_id, subject_artifact_id,
subject_version_id, subject_frame_id, source_frame_id, origin
(extractor/agent_tool/user), evidence
(stated/observed/inferred), superseded_by, last_surfaced_at.
poller_lease — single-writer guard for compute polling. provider,
holder, expires_at.
These are rejected with Table '<name>' is not queryable — use the listed
SDK accessor instead.
oauth_tokens,
user_secrets, anthropic_api_keys, cloud_credentials. →
host.credentials.list() for non-secret metadata; .get(name) for
the decrypted fields — usable in client libraries, redacted only from
printed cell output.user_agents, agents, custom_agent_prompts,
bundled_agent_settings, capability_settings, custom_skills,
agent_skill_assignments, custom_mcp_servers, mcp_agent_assignments,
mcp_tool_grants, directory_attachments. → host.agents.list() /
host.skills.list() / host.agents.list_connectors() (load the
customize skill for that API).host_grants. → the list_host_grants tool
(present on sandboxed-network builds).compute_providers. → the
list_compute / compute_details tools.The denylist matches on word boundaries anywhere in the SQL, so a column alias or string literal that happens to equal a denied table name will also be rejected.
Host identity (hostname, workspace/pod name) is intentionally not exposed
anywhere in this DB (and on Linux builds the sandbox masks it as well) — to
know where you're running, ask the user or use list_compute labels.
All of these run via the repl tool.
# Token and cost accounting across every frame in THIS PROJECT (all
# sessions). Add `WHERE root_frame_id = ?` with the current root's id to
# scope to one session tree. Aggregate server-side so the row cap can't
# undercount.
r = host.query("""
SELECT COUNT(*) AS n_frames,
SUM(input_tokens) AS input_tokens,
SUM(output_tokens) AS output_tokens,
SUM(cache_read_tokens) AS cache_read_tokens,
SUM(cache_write_tokens) AS cache_write_tokens,
SUM(total_cost) AS total_cost
FROM frames
""")
n, itok, otok, crd, cwr, cost = r["rows"][0]
print(f"{n} frames, ${cost or 0:.4f} total")# Last 10 code cells executed in this project (any frame), with outcome.
# Add `WHERE e.frame_id = ?` with the current frame's id to scope to one
# frame.
host.query("""
SELECT e.frame_id, e.cell_index, e.language, e.kernel_kind, e.conda_env,
e.exit_status, substr(e.source, 1, 120) AS src,
json_array_length(e.files_written) AS n_files
FROM execution_log e
ORDER BY e.created_at DESC
LIMIT 10
""")# How far into context is each root conversation in this project? Reads
# _messages length and compaction count without pulling the whole blob.
host.query("""
SELECT id, name,
json_array_length(context_data, '$._messages') AS n_messages,
json_extract(context_data, '$._compaction_count') AS compactions,
input_tokens, output_tokens
FROM frames
WHERE parent_frame_id IS NULL
ORDER BY updated_at DESC
""")# Every artifact this project has, with current size/type, newest first.
host.query("""
SELECT a.filename, v.content_type, v.size_bytes, v.version_number,
a.is_user_upload, a.latest_version_id
FROM artifacts a
JOIN artifact_versions v ON a.latest_version_id = v.id
WHERE a.is_ephemeral = 0
ORDER BY v.created_at DESC
""")The host object is a Python SDK backed by host-side RPCs. Run
help(host) / help(host.<x>) for signatures.
| Accessor | Tool | Returns |
|---|---|---|
host.query(sql, params, limit, df) | repl | Raw SQL over the tables above |
host.frames(...) | repl | List/search/detail frames (paginated messages) |
host.children() | repl | Live sub-agents (delegation-enabled profiles only) |
host.delegate(task_or_list, name=?, profile=?, output_schema=?, model=?) | repl | Spawn child agent(s), block until done (ultra-mode roots; requires [delegation] sdk_enabled). model= pins the child's model per request — e.g. a haiku-class id for cheap fan-outs. Blocks the cell — for long-running children run it in a background cell (a user message mid-call backgrounds it; a Stop / cell interrupt cancels the children) |
host.agents.* / host.skills.* | repl | Profile and skill CRUD — load customize skill |
host.submit_output(output, completion_bullets=[...]) | repl | Submit your structured result when your task carries an OUTPUT SCHEMA section (required before completing). Build the dict in-kernel — the payload rides the host-call wire, not your prose; on a validation/review bounce, mutate the dict in memory and resubmit (replaces the recorded output) |
host.compute.* | repl | Remote job submit/wait — load the compute skill it names |
host.artifacts(...) | python | Filtered artifact search (wraps the join above) |
host.artifact_path(vid) / host.artifact_marker(vid) | python | Resolve a version_id to a readable path / marker |
host.lineage[vid] | python | {code, messages, env, inputs} for one version |
host.llm(prompt_or_list, model=?, ...) | python | Single-turn completion via the host's API client. Omitting model= uses the Haiku-class kernel default (via [llm] kernel_default_model); for harder reasoning pass model=host.current_model() — never hardcode a literal model id (they go stale) |
host.credentials.list() / .get(name) | python | User-configured credential metadata |
host.mcp(server, method, **kw) | repl | MCP/connector call — only exists in the repl tool; pass results to python/r via ./handoff/*.json |
The repl tool and the python tool are separate processes that share
only the workspace directory — move data between them via
./handoff/*.json, not variables.
© JimLiu, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Just SKILL.md in skills/self-awareness of JimLiu/science-skills.
Open the folder on GitHubat commit fb309c3
We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in JimLiu/science-skills, which our catalogue first saw on October 7, 2026.
Self Awareness next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Self Awareness this skillJimLiu/science-skills | 228 | 2 repos | ~3.4k | Automated safety check: Pass | Apache-2.0 | |
| Add Memory KindEverMind-AI/EverOS | 13k | — | ~2.6k | Automated safety check: Pass | Apache-2.0 | |
| Cursor BYOK Database Schemaleookun/cursor-byok | 3.2k | — | ~1.3k | Automated safety check: Pass | MIT | |
| ERPClaw ERP Controlleravansaber/erpclaw | 116 | — | ~18k | Automated safety check: Pass | GPL-3.0 | |
| Golang Databaseunxed/f4 | 243 | 2 repos | ~2.9k | Automated safety check: Pass | MIT | |
| Database Expertcin12211/orca-q | 224 | — | ~2.8k | Automated safety check: Pass | MIT |
EverMind-AI/EverOS
Walks through adding a new persisted memory kind to EverOS: choose storage among Markdown, SQLite and LanceDB, pick a Markdown strategy, then wire schemas, repos and writers.
leookun/cursor-byok
Guides SQLite schema changes in the Cursor BYOK server, keeping SQLx migrations, the Rust store, API contracts and fixtures aligned.
avansaber/erpclaw
Operates the ERPClaw self-hosted ERP in plain language: accounting, invoicing, inventory, purchasing, tax, HR, payroll and reports, treating the ERP as the single source of truth.
unxed/f4
Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context…
cin12211/orca-q
Database performance optimization, schema design, query analysis, and connection management across PostgreSQL, MySQL, MongoDB, and SQLite with ORM integration.
fastrepl/anarlog
Design or review schemas for crates/cloudsync using SQLite Sync constraints, not generic SQLite advice.
JimLiu/science-skills
Biohub ESMFold2 / ESMFold2-Fast all-atom co-folding (Candido et al.
JimLiu/science-skills
Set up a compute environment on a remote provider so Claude Science jobs can run there.
JimLiu/science-skills
Predict genome-wide functional tracks (RNA-seq, CAGE, DNase, ChIP) from DNA sequence with Borzoi.
JimLiu/science-skills
Score, embed, and generate DNA sequences with Evo 2, a long-context genomic foundation model.
JimLiu/science-skills
Embed proteins with Meta AI's ESM-2 (fair-esm package). An agent skill from JimLiu/science-skills.
JimLiu/science-skills
Structure prediction using OpenFold3, an open-weights PyTorch reproduction of AlphaFold3 from the AlQuraishi Lab.
Works with
Categories
Claude Science's own session database schema and SDK surface for introspection via host.query(). Self Awareness is an agent skill from JimLiu/science-skills.query().
Self Awareness fits situations like: tasks that involve Database schema design; tasks that involve Accounting and bookkeeping.
Run `npx skills add JimLiu/science-skills --skill self-awareness -a claude-code`. Or copy the skill folder (skills/self-awareness in JimLiu/science-skills) into .claude/skills/self-awareness in your project. Claude Code loads it when a task matches its description.
Run `npx skills add JimLiu/science-skills --skill self-awareness -a codex`. Or copy the skill folder (skills/self-awareness in JimLiu/science-skills) into .agents/skills/self-awareness in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add JimLiu/science-skills --skill self-awareness -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/self-awareness, .gemini/skills/self-awareness, .github/skills/self-awareness and .opencode/skills/self-awareness in your project.
SKILL.md names no scripts, command-line tools or credentials: Self Awareness is instructions for the agent only. Our summary lists: Python 3.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Self Awareness is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.
About 3.4k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Self Awareness: Add Memory Kind (EverMind-AI/EverOS, 13k stars), Cursor BYOK Database Schema (leookun/cursor-byok, 3.2k stars), ERPClaw ERP Controller (avansaber/erpclaw, 116 stars) and Golang Database (unxed/f4, 243 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
JimLiu (a GitHub user) maintains it in JimLiu/science-skills, which has 228 GitHub stars. The repository holds 27 skills in this directory. The repository was last updated on July 1, 2026.
Source: JimLiu/science-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.