Skip to content
Back to search

genomi

SkillWorks with Claude CodeGitHub

Use this skill for genetics, genome source, variant, gene, phenotype, disease, screen, pharmacogenomics, and Genomi install/setup maintenance questions.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/exon-research/genomi with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/exon-research/genomi'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/exon-research--genomi/badge.svg)](/listings/exon-research--genomi)

HTML

<a href="/listings/exon-research--genomi"><img src="/api/listings/exon-research--genomi/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 319 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: genomi
  3. description: Use this skill for genetics, genome source, variant, gene, phenotype, disease, screen, pharmacogenomics, and Genomi install/setup maintenance questions.
  4. ---
  5. # Genomi
  6. Genomi gives agents local tools for genetics and DNA-aware evidence work. Use it
  7. when the user's request is about variants, genes, phenotypes, disease genes,
  8. biological screens, medication response, ancestry reference-panel context,
  9. polygenic-score context, or a
  10. genome source.
  11. ## How To Call Genomi
  12. Call Genomi through the MCP server: `mcp__genomi__<operation>` (or your
  13. host's equivalent namespace).
  14. If those tools are missing from the current session's tool list but the
  15. host's MCP list shows Genomi connected, the session pre-dates the server's
  16. registration. Ask the user to start a new session.
  17. ## Core Rules
  18. - Public by default: if the chat has not mentioned a genome source, answer
  19. from public/tool sources only.
  20. - Active Genome Index context is chat-scoped: use it only when this conversation
  21. provides a genome source, names a previous run, asks about the selected Active Genome Index
  22. context, or says something like "my Active Genome Index" or "my genome".
  23. - If the user provides a genome source path in this chat, that is approval to read
  24. that source for this session.
  25. - If the user says "my Active Genome Index" or "my genome" without a path, it is acceptable to
  26. check for an already imported Active Genome Index context.
  27. - Reading imported/parsed Active Genome Index artifacts, resuming a previous run for
  28. evidence, or searching for an existing "my Active Genome Index"/"my genome" context requires
  29. explicit user approval for this session. Record approval with
  30. `active_genome_index.approve_access` before calling those tools.
  31. - A configured default user may select an Active Genome Index as metadata, but
  32. default selection never replaces current-session read approval.
  33. - Do not use unrelated genome sources from other chats, workspaces, or external
  34. evaluation tasks.
  35. - Call narrow tools first and inspect evidence before making a claim.
  36. - Treat this root skill as static startup guidance. Do not infer live session
  37. state from it; use `genomi.describe_context`,
  38. `genomi.check_libraries`, and tool result envelopes for changing context.
  39. - If an MCP tool returns `status="in_progress"`, call
  40. `genomi.check_background_job` with the returned `job_id`. Do not retry the
  41. same work with a capped parse or raw text scan unless the user asks for that
  42. fallback.
  43. - Only send parameters supplied by the current user request, current Genomi
  44. context, a previous Genomi result, explicit user approval, or an explicit
  45. override. Omit unknown optional parameters.
  46. - Defaults are part of the reasoning chain. Tool definitions expose
  47. `parameterDefaults`; returned results include `defaults_applied` for omitted
  48. defaults so the host agent can inspect and override them in a follow-up call
  49. when the user intent requires it.
  50. - Tool definitions expose `dependencyContract` when a tool needs local
  51. installed libraries or external network/API sources. Missing local libraries
  52. return `requires_library_install`; unavailable external sources return
  53. `source_unavailable`; local source-file requirements appear as
  54. `localResources`.
  55. - In the final answer, mention Active Genome Index use only when it materially
  56. affects the result: for example, it supports or refutes a user-specific claim,
  57. changes a limitation, blocks an operation until approval, or explains a
  58. required next action. Do not add a routine source-status line.
  59. - Derive confidence dynamically for each Genomi-guided answer from tool
  60. evidence, source trust, coverage, conflicts, and missing evidence. Do not use
  61. a static default confidence or a user-selected confidence profile.
  62. Genomi result fields describe evidence support, coverage, overlap, and source
  63. state; they are not final answer-confidence labels.
  64. - Use `genomi.describe_context` when the user asks about personal context,
  65. their own genome/context, a genome source, a previous run, a selected user,
  66. or before making sample-specific claims. When you call it, inspect
  67. `active_response_profile.guidance`; the active profile id is persisted in
  68. the Genomi registry (set via `genomi.set_response_profile`) and falls back
  69. to the catalog default when none is set. Do not call it only to bootstrap a
  70. public-only question.
  71. - Handle Active Genome Index lifecycle states yourself. When a read op's
  72. envelope or `genomi.describe_context` returns
  73. `active_genome_index_readiness.status == "needs_reparse"`, look up the recorded source
  74. path under `active_genome_index.agi_intake_source_path` and call `genomi.parse_source`
  75. with it — routine maintenance, no user prompt needed. Only ask the user
  76. when `availability.agi_intake_source_path` is false (path moved or deleted) or the
  77. status is `schema_too_new` (Genomi runtime out of date). Never proceed
  78. with a stale Active Genome Index while silently substituting placeholder data;
  79. use the Active Genome Index skill for the full procedure.
  80. - For search-like operations, pass host-inferred alternate wording in
  81. `semantic_context` when the current chat reasonably supports alternate
  82. biomedical wording. Send the user's original wording as `raw_query`, add
  83. `host_expansions` only as retrieval terms, and add `host_entities` for helpful
  84. proposed spans such as drug, gene, phenotype, trait_or_condition, variant, or
  85. rsid. These terms are retrieval inputs, not evidence; Genomi reports
  86. source/retrieval hits in `term_matches` and no-hit terms in `term_misses`.
  87. ## Routing
  88. MCP `tools/list` returns only the default set:
  89. - Core `genomi.*`, `research.*`, and `journal.*` operations.
  90. - The complete direct `genomilab.*` host-application boundary.
  91. - `genomi.invoke` — the dispatcher for every other capability tool.
  92. Before using a `genomilab.*` operation, load `skills/genomilab/SKILL.md`.
  93. Those tools keep the current Claude/Codex task in control; they require a
  94. query-ready selected Active Genome Index, bind patient authorization to the
  95. current MCP session, and use the portal only for onboarding, exact approvals,
  96. provider setup, and committed-event monitoring.
  97. To use a non-base capability tool, load the matching focused capability skill,
  98. then call:
  99. ```
  100. genomi.invoke({"tool": "<operation_name>", "params": {...}})
  101. ```
  102. Example:
  103. ```
  104. genomi.invoke({"tool": "variant.resolve", "params": {"rsid": "rs429358"}})
  105. ```
  106. The dispatcher validates the registered operation name, runs the underlying tool's
  107. input-schema validation, and returns the underlying tool's response with an
  108. added `dispatched_tool` field.
  109. Operation namespaces are tool-name prefixes, not disclosure branches. Use
  110. namespace filters only for debugging or audits.
  111. Resolve context, select the intent capability, read its skill markdown, call
  112. the smallest useful operation through `genomi.invoke` (or direct call for
  113. base tools), inspect evidence, journal material findings, and continue until
  114. the answer is supported. Use `genomi.describe_context` only when this chat
  115. asks about personal context, the user's own genome/context, Active Genome Index
  116. context, a selected user, a genome source, or a previous run.
  117. ## Setup
  118. `genomi.install` installs **or updates** Genomi, and `genomi install` /
  119. `genomi update` are the same operation. It always updates everything that can
  120. be updated: the runtime code (`git pull --ff-only` on a git checkout, unless
  121. `GENOMI_SKIP_RUNTIME_GIT_PULL` is set for a non-git distribution), all public
  122. reference libraries into `GENOMI_HOME` (idempotent — each installed library is
  123. checked against its source and re-downloaded only if it changed upstream, so
  124. re-running transfers nothing when nothing changed; pass `force` to re-download
  125. regardless), host-agent skill symlinks in detected host skill directories
  126. (including stale/dangling repair and obsolete Genomi capability-link removal),
  127. the public retrieval indexes, and a
  128. background reparse of any genome whose index schema is older than the updated
  129. runtime's. There are no per-step skip flags — `genomi update` does the full
  130. update by default. The `libraries` parameter only narrows *which* reference
  131. libraries to materialize (default `everything`): pass a specific library (or
  132. comma-separated set) to install just those — both for an install-time subset
  133. the user chose and to add a single new library on demand at runtime (the
  134. "install this missing library" path). To see which libraries are already
  135. installed vs missing before deciding, call `genomi.check_libraries` (its
  136. summary reports `installed_count` / `missing_count`). This applies once Genomi
  137. is installed; first-time setup on a machine without the `genomi` runtime
  138. follows the source bootstrap in `INSTALL_FOR_AGENTS.md`.
  139. ## Parsing A Genome Source
  140. `genomi.parse_source` is a core `genomi.*` tool: it detects, parses, and
  141. digitizes a genome source (VCF/gVCF, BAM, paired-end FASTQ, or a
  142. consumer-array raw genotype export from 23andMe, AncestryDNA, MyHeritage,
  143. FamilyTreeDNA, or Living DNA; bare text/CSV, gzip/bzip2/xz-compressed, or
  144. inside a zip/tar archive; or a `.genome/1.0` bundle such as
  145. `sample.genome.tar.gz`) into a queryable Active Genome Index.
  146. - **Use when**: the user supplied a genome source in this chat and downstream
  147. questions need a queryable Active Genome Index this session.
  148. - **Why**: raw VCF/BAM/genotype files are too large and irregular for reliable
  149. direct reasoning; parsing builds the scoped index later tools query.
  150. - **Not for**: public-only genetics questions, selecting an already-parsed
  151. index, or capped sample scans that should not replace a complete index.
  152. - **Result**: digitizes local intake into an Active Genome Index; Genomi
  153. auto-detects the source type. Supplying `user_nickname` links the parsed
  154. artifact to a user profile. It does not run whole-callset annotation —
  155. focused tools materialize public libraries lazily when their evidence is
  156. needed.
  157. - If it returns `status="in_progress"` with a `job_id`, poll
  158. `genomi.check_background_job`; don't substitute a capped parse or raw scan
  159. unless the user explicitly asks for a fallback.
  160. - **gVCFs parse in two phases.** A gVCF is ~96% reference blocks, so the parse
  161. returns as soon as **every variant** is stored and indexed — the result
  162. reports `variants_ready` (not yet `completed`) and the whole interpretation
  163. surface (rsID, gene, region, exact-allele lookup, ClinVar, PRS, …) is already
  164. correct. The reference-block tail is appended by a detached background job
  165. (`active_genome_index.build_reference_pass`) whose `job_id` is surfaced in the
  166. result's `next_actions`. Until that job reports `completed`, only "is this
  167. locus confirmed reference vs not-callable" coverage answers are provisional —
  168. every readiness/coverage result carries `reference_pending` to say so. Plain
  169. VCFs, small files, and capped (`max_records`) parses stay single-phase. Other
  170. sources (consumer arrays, BAM/FASTQ) have no reference tail to defer.
  171. - **After a parse, offer to name the profile.** When the user did not pass
  172. `user_nickname`, the result includes an `ask_user` next action: ask them for a
  173. profile nickname and whether to set it as the machine default, then record it
  174. by re-running with `user_nickname` (+ `set_default_user=true`) or via the
  175. invoke-only `active_genome_index.assign_user_genome` / `set_default_user`
  176. tools — exactly the offer `INSTALL_FOR_AGENTS.md` Step 8 makes.
  177. The parse/digitize/user-management **workflow** (selecting users, approving
  178. access, assigning a genome to a profile, lifecycle reparse) lives in the Active
  179. Genome Index skill, which also owns the
  180. `active_genome_index.*` interpretation tools.
  181. ## Journal
  182. Use journal when an investigation spans multiple Genomi tools and the host
  183. agent needs to record reasoning over evidence. Journal entries are agent notes
  184. with traceability links; they are not source evidence and should not be used as
  185. candidate-ranking `source_records`.
  186. ## Default Tools
  187. These tools appear in the default tool list. Their full metadata is available
  188. without expansion.
  189. Genomi context and users:
  190. - `genomi.check_background_job`
  191. - `genomi.check_libraries`
  192. - `genomi.describe_context`
  193. - `genomi.install`
  194. - `genomi.invoke`
  195. - `genomi.list_resources`
  196. - `genomi.search_indexes`
  197. - `genomi.set_response_profile`
  198. Active Genome Index:
  199. - `genomi.parse_source`
  200. All other `active_genome_index.*` and focused genetics tools are invoke-only:
  201. reach them via `genomi.invoke` after loading the matching capability skill.
  202. GenomiLab Research Desk (default-complete):
  203. - `genomilab.open_workspace`
  204. - `genomilab.create_investigation`
  205. - `genomilab.form_specialist_board`
  206. - `genomilab.report_specialist_progress`
  207. - `genomilab.record_specialist_report`
  208. - `genomilab.inspect_investigation`
  209. - `genomilab.prepare_authorization`
  210. - `genomilab.record_patient_observations`
  211. - `genomilab.submit_plan`
  212. - `genomilab.execute_request`
  213. - `genomilab.check_request`
  214. - `genomilab.submit_brief`
  215. - `genomilab.submit_research_artifact`
  216. - `genomilab.verify_sequence_substitution`
  217. - `genomilab.run_esm_substitution_analysis`
  218. - `genomilab.run_proto_blinded_experiment_design`
  219. - `genomilab.list_research_artifacts`
  220. - `genomilab.list_research_tools`
  221. - `genomilab.revoke_context`
  222. The agent creates investigations and owns all task lifecycle. The portal must
  223. not create, message, or cancel an agent task. A repeated local stdio MCP
  224. initialize is a new agent session and requires renewed patient authorization
  225. before private investigation state becomes visible. HTTP MCP initialization is
  226. public-tools-only and cannot create or replace the private GenomiLab runtime.
  227. Public research:
  228. - `research.build_target_packet`
  229. - `research.list_sources`
  230. - `research.query`
  231. - `research.record`
  232. - `research.search`
  233. Journal:
  234. - `journal.append_entry`
  235. - `journal.export_memory`
  236. - `journal.search_entries`
  237. - `journal.summarize`
  238. ## Candidate Evidence
  239. Candidate and ranking operations return evidence views, `decision_evidence`,
  240. warnings, and coverage.
  241. Use source-specific candidate-gene tools instead of a universal comparator:
  242. `phenotype.compare_gene_hpo_evidence` for HPO/single-subject phenotype
  243. matching, `gwas.compare_gene_associations` for GWAS Catalog gene-field
  244. evidence, `phenotype.compare_drug_target_evidence` for drug-target evidence,
  245. and `functional_genomics.compare_gene_perturbation` for perturbation evidence.
  246. `phenotype.retrieve_trait_gene_records` retrieves trait-to-gene records from integrated
  247. sources. Records labelled `association_only_not_causal` are visible evidence,
  248. not an answer.
  249. Any operation that exposes an answer-shaped candidate result must expose the
  250. evidence behind that result. Use that evidence for the host-agent decision.
  251. ## Multi-Stream Synthesis
  252. When multiple Genomi capabilities can contribute orthogonal evidence to the
  253. same question, combine them — both in the initial plan and in follow-ups.
  254. A scope-limited single-capability result (missing calibration, no record at
  255. locus, association-only, library-not-installed, low overlap, source
  256. unavailable, etc.) is not a final user-facing answer when other Genomi
  257. capabilities can contribute orthogonal evidence to the same question.
  258. Returning "I cannot answer" while applicable capabilities remain unexamined
  259. is a host-agent failure mode, not a Genomi limitation.
  260. When multiple plausible plans differ materially in cost, surface the choice
  261. once with the tradeoff and commit to the user's pick. Over-checkpointing is
  262. itself a failure mode.
  263. ## Answering
  264. Lead with the answer. When a finding is grounded in a public dataset
  265. (ClinVar, GWAS Catalog, PGS Catalog, 1000 Genomes panel, etc.) and that
  266. source materially shapes the result, name the dataset inline in the
  267. prose. Keep clinical language informational and recommend clinical
  268. confirmation for medical decisions. Confidence is an answer-time
  269. synthesis judgment, not static metadata. Adapt explanation depth to the
  270. selected response profile without weakening evidence limits, privacy
  271. boundaries, or clinical-confirmation language.
README.md · README · 662 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="assets/genomi-logo.png" alt="Genomi logo" width="160">
  3. <br>
  4. <strong>Your genome. Decoded.</strong>
  5. <br>
  6. <a href="https://www.genomiagent.com/">Website</a>
  7. ·
  8. <a href="https://raw.githubusercontent.com/exon-research/genomi/master/INSTALL_FOR_AGENTS.md">Install guide</a>
  9. ·
  10. <a href="README.zh-CN.md">简体中文</a>
  11. </p>
  12. <p align="center">
  13. <a href="https://www.python.org/downloads/"><img alt="Python" src="https://img.shields.io/badge/python-3.10%2B-3776AB?style=flat-square&logo=python&logoColor=white&labelColor=111827"></a>
  14. <a href="https://github.com/exon-research/genomi/releases/tag/v0.1.0"><img alt="Version" src="https://img.shields.io/badge/version-0.1.0-2563EB?style=flat-square&labelColor=111827"></a>
  15. <a href="https://modelcontextprotocol.io/"><img alt="MCP" src="https://img.shields.io/badge/MCP-agent--native-7C3AED?style=flat-square&labelColor=111827"></a>
  16. <a href="SKILL.md"><img alt="Skill" src="https://img.shields.io/badge/skill-agent--ready-0E7490?style=flat-square&labelColor=111827"></a>
  17. <a href="#privacy"><img alt="Local-first" src="https://img.shields.io/badge/privacy-local--first-15803D?style=flat-square&labelColor=111827"></a>
  18. <a href="LICENSE"><img alt="License" src="https://img.shields.io/badge/license-Apache--2.0-64748B?style=flat-square&labelColor=111827"></a>
  19. </p>
  20. # Genomi
  21. > Am I going bald? What does my DNA say about Alzheimer's risk? Why does
  22. > ibuprofen do nothing for me?
  23. DNA is the layer underneath all of that. It shapes the proteins, enzymes,
  24. receptors, and pathways behind nutrition, medication response, sleep,
  25. exercise, inherited traits, and risk for some conditions. Not destiny. But
  26. the most personal data you carry.
  27. And it is overwhelming. ~3 billion base pairs, 20,000+ genes, millions of
  28. observed variants per person. No clinician, no lab, no individual holds that
  29. in their head. It is too much.
  30. We live in an era where AI can take on tasks that were not possible before,
  31. at scales never seen before. Your genome is exactly that kind of task. And
  32. for the first time, we have the tools to actually read it at the scale it
  33. lives at.
  34. Genomi is an open-source AI agent runtime that turns your AI agent into a personal DNA expert.
  35. Works with Claude Code, Codex, OpenClaw, Hermes, and any MCP-capable host. It gives the agent a private
  36. workspace: your variants in a local Active Genome Index, public genetics evidence ready to
  37. query, memory of what you explored, and report tools that turn DNA questions
  38. into evidence-backed answers. Your genome stays on your machine. The agent
  39. does the work.
  40. ## Launch video
  41. <p align="center">
  42. <a href="https://youtu.be/8CkoDNlyvZ0">
  43. <img src="https://img.youtube.com/vi/8CkoDNlyvZ0/maxresdefault.jpg" alt="Genomi launch video" width="640">
  44. </a>
  45. </p>
  46. ## See it in action
  47. - [Genomi parses your raw DNA file into a local database your agent can query](https://youtu.be/mJUw6Lf8zEk)
  48. - [Genomi keeps your raw DNA file on your machine](https://youtu.be/Paj2ixdeZGk)
  49. - [Genomi knows when to say "No" and "I don't know"](https://youtu.be/-yXZhFDiYP0)
  50. - [Genomi evolves — your agent self-updates to sync with the latest research](https://youtu.be/ih_7elp2H2w)
  51. ## TL;DR
  52. Even TL;DR is too long, just paste this to your agent:
  53. ```text
  54. Hey please read this and tell me why Genomi is different from other AI
  55. agent harnesses. Why is this actually useful for understanding my DNA privately?
  56. https://raw.githubusercontent.com/exon-research/genomi/master/llms-full.txt
  57. ```
  58. ## Just Install It
  59. Install it through your agent. Paste one instruction, answer a few questions,
  60. and let your agent wire up the runtime:
  61. ```text
  62. Install and configure Genomi by following the instructions here:
  63. https://raw.githubusercontent.com/exon-research/genomi/master/INSTALL_FOR_AGENTS.md
  64. ```
  65. The install guide covers dependency checks, library selection, MCP
  66. registration, optional genome-source import, and verification. If Genomi is
  67. already packaged or otherwise present, the canonical install/update path is
  68. `genomi install` or the MCP operation `genomi.install`; the source bootstrap is
  69. only for hosts that do not have Genomi yet.
  70. ## GenomiLab Local Research Workspace (Developer Preview)
  71. GenomiLab is the patient-facing disease-investigation application built on
  72. Genomi. Ask the Claude Code, Codex, or other MCP host that already runs
  73. `genomi serve` to open the Research Desk. The same long-lived Genomi MCP process
  74. owns the session-scoped Active Genome Index handle, GenomiLab domain service,
  75. encrypted research store, and loopback portal. GenomiLab does not discover or
  76. launch a second embedded agent server.
  77. A current Genomi user with a query-ready Active Genome Index (AGI) selected is
  78. required before the Research Desk opens. Genome intake remains a core Genomi
  79. setup step: the user can simply give the host agent the local VCF, gVCF, or
  80. other supported genome-source path, and the agent prepares and selects the AGI.
  81. On a fresh Genomi home, that path alone creates an immediately usable local
  82. placeholder profile; the patient can rename it later. Only an existing
  83. ambiguous multi-user home needs a follow-up choice about which profile owns the
  84. genome. After that, every GenomiLab investigation reuses the active AGI; it
  85. never asks for another genome upload or copies AGI rows into its own database.
  86. The underlying host owns the conversation, native task lifecycle, planning,
  87. subagents, tool calls, streaming, follow-ups, resume, and cancellation.
  88. GenomiLab supplies its focused skill, typed patient-research capabilities,
  89. scoped authorization, durable evidence/hypothesis/brief records, and validation
  90. at those boundaries. The web portal is for patient onboarding, molecular-profile
  91. updates, exact approvals, provider setup, and monitoring committed domain
  92. events. It does not start, message, or cancel a host task.
  93. For each new investigation, the main host agent chairs a required board of 2–5
  94. adaptive, non-overlapping native specialist subagents. The chair keeps the
  95. patient conversation, authorization, private AGI reads, and canonical research
  96. commits; specialists receive bounded public questions or only the minimum
  97. approved evidence they need. GenomiLab records the logical board and meaningful
  98. milestone states for the portal, never raw agent messages, chain of thought, or
  99. native task identifiers. A resumed investigation reuses its recorded board.
  100. Follow-up information stays in that same host task and investigation. The host
  101. records the new patient observation, the patient approves the exact context
  102. change in the portal, and the host reruns only affected evidence before
  103. committing a superseding hypothesis and revised brief.
  104. Those GenomiLab capabilities go beyond both base Genomi and a general harness:
  105. they project an approved Patient Molecular Profile, preserve source-separated
  106. disease evidence, relate public findings to exact patient observations, and
  107. maintain hypotheses, counterevidence, gaps, confirmation needs, and versioned
  108. patient/clinician briefs. Paperclip supports a narrow, approved set of
  109. literature, regulatory, and trial-registry discovery operations. It does not
  110. provide full-text extraction or claim verification. A Paperclip API key can be
  111. saved securely and checked with a fixed public `TP53`/PMC/one-result probe, but
  112. that check alone enables no evidence operation. Investigation use still
  113. requires the applicable owner-provided deployment policy, patient-data
  114. contract, and exact just-in-time disclosure approval; without that
  115. configuration, GenomiLab advertises no live Paperclip route.
  116. Biohub ESM and Proto connection checks remain setup checks and never count as
  117. scientific execution. GenomiLab separately exposes one bounded ESM
  118. reference-versus-substitution operation and one bounded Proto blinded
  119. experiment-design operation only when their respective configured executors
  120. are local and network-disabled. If an executor is absent, the operation is
  121. explicitly `unavailable` and creates no artifact. Completed outputs are
  122. immutable, round-bound nonclinical research artifacts, not evidence: they
  123. cannot support hypotheses, brief claims, answer-readiness, treatment content,
  124. or clinician export.
  125. Deployment owners select installed scientific executors by setting
  126. `GENOMILAB_ESM_SCIENTIFIC_EXECUTOR` and/or
  127. `GENOMILAB_PROTO_SCIENTIFIC_EXECUTOR` to an exact entry-point name registered
  128. under the fixed `genomi.scientific_executors` Python entry-point group before a
  129. fresh MCP session starts. These values are non-secret names, not import paths
  130. or commands. Unset selectors keep the operation unavailable; an invalid,
  131. missing, ambiguous, broken, or non-callable selection fails the new
  132. GenomiLab runtime closed.
  133. Deployment owners who have those Paperclip policy records set
  134. `GENOMILAB_PAPERCLIP_AUTHORIZATION_CONFIG` to the strict JSON policy file before
  135. the MCP host starts `genomi serve`. The file contains policy and contract
  136. records, never the API key; the patient saves that credential in the portal.
  137. The host can inspect those truthful states with
  138. `genomilab.list_research_tools`; credentials and connect/disconnect actions
  139. remain in the patient portal.
  140. Provider secrets and the GenomiLab database encryption key use the native OS
  141. credential store. The research records themselves stay in encrypted SQLite;
  142. the credential store holds only key material, so a database copied without the
  143. local OS account's key is not readable. This is a different requirement from
  144. the core AGI/query stores, which hold local genomic query artifacts under their
  145. own access boundary and are never duplicated into GenomiLab.
  146. The portal binds to a random loopback-only address and opens with a one-time
  147. private launch link. Each investigation uses an immutable, consented molecular
  148. profile snapshot, an exact AGI revision, and a bounded genomic scope. Access is
  149. revoked when the Genomi MCP workspace session ends or the current Genomi user
  150. changes. Each local stdio MCP `initialize` handshake starts a new GenomiLab
  151. workspace session and closes any prior one in that process, even when the
  152. client name and version are unchanged; hosts should not reinitialize the stdio
  153. connection in the middle of an investigation turn. HTTP MCP initialization is
  154. public-tools-only and cannot create or replace the private GenomiLab runtime.
  155. Durable investigation records remain, but a new private session must renew
  156. private-context authorization before reading them.
  157. Optional external providers and biological models are behind explicit
  158. eligibility and patient-data disclosure gates; connection verification never opens a
  159. patient-informed route, and unavailable capabilities fail closed.
  160. This remains a research-support developer preview, not a diagnosis or treatment
  161. product. Findings and proposed clinical implications require appropriate
  162. clinical confirmation and review.
  163. ## Works With Every Agent
  164. Genomi is not tied to one chat app. Any agent host that can use MCP tools,
  165. local commands, or installed skills can talk to the same local Genomi runtime.
  166. | Host family | How Genomi connects |
  167. | --- | --- |
  168. | Claude Code | MCP server plus Genomi skills |
  169. | Codex CLI | MCP server plus Genomi skill |
  170. | OpenCode, OpenClaw, Hermes | MCP server plus host skill where supported |
  171. | Cursor, Gemini CLI, Cline, Goose, Roo Code, Windsurf, Claude Desktop | MCP server |
  172. | Any other MCP-capable host | `genomi serve` over stdio |
  173. One local Genomi home can hold the public libraries, Active Genome Index
  174. records, score caches, and journals. Session access still follows Genomi's
  175. approval rules, but the underlying evidence workspace is reusable across host
  176. agents.
  177. ## Or If You Prefer The Old-School Way
  178. Clone, install, point your MCP-capable agent at it. Same flow the installer
  179. script runs, just done by hand. The
  180. [install guide for agents](INSTALL_FOR_AGENTS.md) is the canonical reference —
  181. if anything below drifts from it, that doc wins.
  182. 1. **Get the source.**
  183. ```bash
  184. git clone git@github.com:exon-research/genomi.git ~/.genomi/genomi
  185. cd ~/.genomi/genomi
  186. ```
  187. 2. **Install the package + public libraries.** The recommended install grabs
  188. every default reference library so Genomi can answer real questions without
  189. stopping later to fetch missing data. Use a smaller purpose from the catalog
  190. only when disk, bandwidth, or time is constrained (`common-questions`,
  191. `medication-response`, `ancestry-context`, `sequence-and-regions`,
  192. `cell-and-tissue`, `everything`, or `setup-only`):
  193. ```bash
  194. export GENOMI_HOME=~/.genomi
  195. python3 scripts/install_for_agents.py --libraries everything
  196. ```
  197. The installer creates a stable command at `$GENOMI_HOME/bin/genomi`.
  198. Add it to PATH if you want `genomi` available from any shell:
  199. ```bash
  200. export PATH="$GENOMI_HOME/bin:$PATH"
  201. ```
  202. Once the `genomi` command exists, use it for install/update:
  203. ```bash
  204. genomi install --libraries everything
  205. ```
  206. 3. **Register the MCP server with your host agent.**
  207. ```json
  208. {
  209. "mcpServers": {
  210. "genomi": {
  211. "command": "/absolute/path/to/GENOMI_HOME/bin/genomi",
  212. "args": ["serve"]
  213. }
  214. }
  215. }
  216. ```
  217. For a source checkout where the stable shim is unavailable:
  218. ```json
  219. {
  220. "mcpServers": {
  221. "genomi": {
  222. "command": "bash",
  223. "args": ["-lc", "cd /path/to/genomi && PYTHONPATH=src python3 -m genomi serve"]
  224. }
  225. }
  226. }
  227. ```
  228. Reload your host's MCP servers. For URL-based ingestion, `llms.txt` is the
  229. compact public map and `llms-full.txt` is one inlined reference file.
  230. ## Ask It Things Like
  231. Once Genomi is wired up, you talk to the agent like this. In Codex, use
  232. `$genomi` instead of `/genomi`. The quick stuff first:
  233. > `/genomi` What does my DNA say about Alzheimer's risk?
  234. >
  235. > `/genomi` Am I at risk for early heart disease?
  236. >
  237. > `/genomi` Am I going bald?
  238. >
  239. > `/genomi` Am I a fast or slow metabolizer?
  240. >
  241. > `/genomi` Should I worry about diabetes?
  242. >
  243. > `/genomi` Am I lactose intolerant?
  244. >
  245. > `/genomi` Is alcohol bad for me specifically?
  246. Then hand it something bigger:
  247. > `/genomi` I'm about to start an SSRI. Walk me through my CYP2D6 and
  248. > CYP2C19 status, what the major guideline sources say about dosing, and
  249. > what's preliminary vs actually actionable.
  250. > `/genomi` Run a pharmacogenomic review across every medication I take.
  251. > Lead with guideline-backed dose adjustments. Flag lower-evidence signals
  252. > second. Tell me what's outside scope.
  253. > `/genomi` Build me a one-page rare-disease workup for my HPO terms.
  254. > Rank candidate genes by source-backed evidence, cite each call, and
  255. > show me what's missing before this is worth taking to a clinician.
  256. Or just hand it the whole thing:
  257. > `/genomi decode`
  258. One command. The agent sweeps every dashboard capability across your genome —
  259. variants, ClinVar, pharmacogenomics, ancestry, polygenic scores, and
  260. nutrigenomics — and serves the result as a self-contained dashboard on
  261. localhost. Open the URL in a browser.
  262. Behind those, Genomi gives the agent grounded tools across 20,000+ human
  263. genes, millions of genotype observations from your file, and the public
  264. evidence sources that keep the answer honest.
  265. ## What Genomi Provides
  266. | Layer | What you get |
  267. | --- | --- |
  268. | Active Genome Index | A local, queryable ledger of alleles, zygosity, quality, depth, filters, and callability context from your genome source. |
  269. | Evidence Library | Focused tools for variants, ClinVar, GWAS, HPO, pharmacogenomics, ancestry context, PRS, and sequence utilities. |
  270. | Journal | A running log of what you explored, what mattered, and which evidence supported it. |
  271. | Skills | Agent instructions for routing questions, asking for approval, preserving source priors, and answering clearly. |
  272. ### Bringing your own genome
  273. Genomi reads your DNA from wherever it already lives. Point it at any VCF or
  274. gVCF you have on disk — clinical exports, research callsets, anything that
  275. follows the spec — and the rest of the pipeline reuses the same Active
  276. Genome Index regardless of where the file came from.
  277. Direct-to-consumer providers are supported natively too. Hand Genomi the
  278. deliverable straight from your account export and it figures out the rest:
  279. - **23andMe**, **AncestryDNA**, **MyHeritage**, **FamilyTreeDNA** (Family
  280. Finder), and **Living DNA** — raw genotype text/CSV as exported by the
  281. provider, including gzip/bzip2/xz-compressed files and zip/tar archives.
  282. - **genome.computer** — `.genome/1.0` bundles with `manifest.json`,
  283. `schema.json`, and partitioned `variants.parquet` records.
  284. - **Nebula Genomics**, **Dante Labs**, and **Sequencing.com** — their VCF
  285. deliverables are recognized and tagged with the originating provider.
  286. - **Nebula / Dante / Sequencing.com FASTQ** — paired-end raw reads are
  287. aligned locally from sibling R1/R2 files or a zip/tar archive containing
  288. the pair (minimap2 for long reads, bwa-mem2 for short reads), sorted, and
  289. then fed into the same BAM → derived-VCF path. The `wgs-alignment`
  290. install purpose pulls down both aligners.
  291. ### No DNA file yet? Try a public one
  292. If you don't have your own genome yet but want to see what Genomi actually
  293. does, the [Personal Genome Project — Harvard Medical School](https://my.pgp-hms.org/public_genetic_data)
  294. publishes real consumer-DNA deliverables from real participants. Their
  295. catalog includes public examples for the common consumer-array, VCF, gVCF,
  296. BAM, and paired FASTQ shapes above; the checked public inventory did not
  297. include a Living DNA example, even though Genomi supports that export shape.
  298. Pick a matching participant export, point Genomi at it, and ask questions.
  299. It is the cleanest way to kick the tires without sequencing yourself.
  300. Genome data is optional for core Genomi public-only genetics questions. A
  301. query-ready selected Active Genome Index is required to open GenomiLab.
  302. ## Why We Built This
  303. I built Genomi because I want AI to take on the things it never could before,
  304. at the scale it never could before — and DNA is exactly that.
  305. A single human genome is overwhelming. Labs spend careers on one gene. Reports
  306. flatten thousands of variants into a single line. Even the best clinician
  307. cannot hold 20,000+ genes and millions of genotype observations in their head.
  308. That is not a limitation of effort. It is a limitation of scale. And it is
  309. the kind of limitation AI is finally good enough to push against.
  310. I want this for my own health. I want it for my family's health. And I want
  311. it to be honest — grounded in real evidence, local by default, with the agent
  312. showing its work instead of guessing from memory.
  313. Raw genome files stay on your machine. Genomi is a workspace, not a static
  314. PDF report. Answers trace back to a source record or they don't get to call
  315. themselves answers. And the whole thing is built for agents over MCP from
  316. the start, not bolted on after.
  317. Generic AI can explain genetics. It should not guess when the question
  318. depends on an exact variant, your genome file, a guideline source, or a
  319. coverage limitation. Genomi gives the agent the tools for the parts that
  320. need evidence, and stays out of the way for the rest.
  321. ## What Genomi Can Help Explore
  322. Genomi is not a static report. It is a private workspace your agent can use to
  323. ask better questions across different parts of your genome.
  324. - Traits and everyday responses: lactose, caffeine, alcohol, taste, nutrition,
  325. sleep, exercise, and similar personal questions.
  326. - Medication response: genes and variants that may affect how your body handles
  327. specific drugs.
  328. - Carrier and inherited-risk context: exact variant checks, ClinVar assertions,
  329. and gene-disease evidence.
  330. - Common-trait research: GWAS and published score context for complex traits,
  331. with clear limits.
  332. - Rare-disease and phenotype review: HPO terms, gene-disease validity, and
  333. source-backed candidate comparisons.
  334. - Ancestry reference-panel context: qualitative reference-panel similarity and
  335. overlap checks, not race or ethnicity prediction.
  336. - Reports and memory: cited Markdown reports and a journal of what you explored,
  337. what mattered, and what still needs follow-up.
  338. ## How Genomi Keeps Answers Honest
  339. DNA questions can be personal, messy, and easy to overstate. Genomi keeps the
  340. pieces separated so an agent can show its work.
  341. - Your genome evidence: genotype, zygosity, depth, quality, filters, exact
  342. allele observation, and callability.
  343. - Public evidence: ClinVar assertions, population frequencies, GWAS records,
  344. gene-disease validity, phenotype annotations, and source versions.
  345. - Reviewed findings: narrow source-backed notes recorded for a specific target
  346. or question.
  347. - Agent memory: observations, decisions, unresolved questions, and links back to
  348. evidence.
  349. - Personal context: optional phenotype, medications, family history, or other
  350. details you choose to provide.
  351. Different evidence families can point in different directions. Genomi helps the
  352. agent compare them without pretending that one database is the whole truth.
  353. ## Privacy
  354. Genomi keeps the most sensitive data close to you.
  355. - Raw genome sources stay on the user's machine.
  356. - Genomi creates Active Genome Index records for personal genome files locally so agents query only the
  357. variants needed for the current question.
  358. - Genomi asks for current-session approval before read operations use any
  359. existing Active Genome Index artifact. A configured default user is
  360. auto-selected as metadata, but that selection does not approve a private
  361. read.
  362. - Public lookups use selected targets such as rsIDs, genes, drugs, conditions,
  363. or guideline questions.
  364. - Journal entries are agent-authored memory, not evidence.
  365. - Project journals reject private/sample evidence links.
  366. - Memory exports omit private evidence links unless explicitly requested and
  367. approved.
  368. ## Sources, Libraries, And Attribution
  369. Genomi talks to trusted, verified databases and specialist genomics tools so
  370. your agent can ground answers in real evidence instead of vibes. Install-time
  371. downloads write source manifests where possible. Live adapters return source
  372. URLs and access context in their result envelopes. Reviewed source families are
  373. not treated as background knowledge; agents cite or journal the specific source
  374. records they used.
  375. Installed Genomi libraries:
  376. - [ClinVar](https://www.ncbi.nlm.nih.gov/clinvar/docs/downloads/) —
  377. `clinvar-grch38` and `clinvar-grch37` VCF caches for exact variant
  378. interpretation lookup.
  379. - [Human Phenotype Ontology](https://obophenotype.github.io/human-phenotype-ontology/annotations/) —
  380. `hpo` phenotype-to-gene and disease annotation files.
  381. - [GenCC](https://search.thegencc.org/download) — `gencc` gene-disease
  382. validity submissions.
  383. - [UCSC Genome Browser downloads](https://hgdownload.soe.ucsc.edu/downloads.html) —
  384. `reference-grch38` and `reference-grch37` hg38/hg19 FASTA files for
  385. sequence, normalization, and callability workflows.
  386. - [UCSC liftOver chain files](https://hgdownload.soe.ucsc.edu/downloads.html#liftover) —
  387. `liftover-chains` for GRCh37/GRCh38 coordinate translation.
  388. - [GENCODE](https://www.gencodegenes.org/human/) — `gencode-grch38` and
  389. `gencode-grch37` transcript annotation GTFs.
  390. - [ENCODE SCREEN](https://www.encodeproject.org/software/screen/) —
  391. `encode-ccre-grch38` candidate cis-regulatory element annotations.
  392. - [PanglaoDB](https://panglaodb.se/markers.html?cell_type=%27all_cells%27)
  393. and [CellMarker 2.0](http://bio-bigdata.hrbmu.edu.cn/CellMarker/) —
  394. `panglaodb-markers` and `cellmarker-human` marker tables.
  395. - [MSigDB Hallmark](https://www.gsea-msigdb.org/gsea/msigdb/human/collections.jsp#H) —
  396. `msigdb-hallmark`, installed only from a user-supplied official GMT export
  397. or URL.
  398. - [PharmCAT](https://pharmcat.org/) and
  399. [PharmGKB](https://www.pharmgkb.org/) — `pharmcat` all-in-one JAR for
  400. pharmacogene diplotypes, phenotypes, and recommendation artifacts.
  401. - [1000 Genomes 30x GRCh38](https://www.internationalgenome.org/data-portal/data-collections/30x-grch38.html) —
  402. `ancestry-1000g-30x-grch38` compact ancestry PCA panel, distributed from
  403. the [genomi-ancestry-panel](https://github.com/exon-research/genomi-ancestry-panel)
  404. build project. `ancestry-1000g-30x-grch37` is derived locally from that
  405. panel with UCSC liftOver chains.
  406. - [minimap2](https://github.com/lh3/minimap2) and
  407. [bwa-mem2](https://github.com/bwa-mem2/bwa-mem2) —
  408. `minimap2-binary` and `bwa-mem2-binary` for optional FASTQ alignment.
  409. BAM/FASTQ workflows also use [samtools and bcftools](https://www.htslib.org/)
  410. when those tools are needed on the host.
  411. Live public adapters and configured public data:
  412. - [gnomAD](https://gnomad.broadinstitute.org/) population frequency lookups.
  413. - [GWAS Catalog](https://www.ebi.ac.uk/gwas/) association-record retrieval.
  414. - [PGS Catalog](https://www.pgscatalog.org/) score metadata and scoring files.
  415. - [ClinPGx](https://www.clinpgx.org/), [PharmGKB](https://www.pharmgkb.org/),
  416. [PGxDB](https://pgx-db.org/), [CPIC](https://cpicpgx.org/guidelines/),
  417. and FDA [pharmacogenomic biomarker](https://www.fda.gov/drugs/science-and-research-drugs/table-pharmacogenomic-biomarkers-drug-labeling/)
  418. and [pharmacogenetic association](https://www.fda.gov/medical-devices/precision-medicine/table-pharmacogenetic-associations)
  419. tables for pharmacogenomic guideline, label, and association context.
  420. - [KEGG](https://www.kegg.jp/kegg/pathway.html),
  421. [Reactome](https://reactome.org/),
  422. [QuickGO](https://www.ebi.ac.uk/QuickGO/),
  423. [Human Protein Atlas](https://www.proteinatlas.org/), and
  424. [ChEMBL](https://www.ebi.ac.uk/chembl/) for pathway, ontology,
  425. tissue/cell-type, compound, and drug-target relationships.
  426. - [Open Targets Platform](https://platform.opentargets.org/) for disease and
  427. clinical drug-target context.
  428. - [BioGRID ORCS](https://orcs.thebiogrid.org/),
  429. [DepMap](https://depmap.org/portal/download/), and
  430. [NCBI GEO](https://www.ncbi.nlm.nih.gov/geo/) for configured or discovered
  431. functional-genomics perturbation evidence.
  432. Reviewed source families:
  433. - [ClinGen Gene-Disease Validity](https://search.clinicalgenome.org/kb/gene-validity),
  434. [GeneReviews](https://www.ncbi.nlm.nih.gov/books/NBK1116/),
  435. [MONDO](https://mondo.monarchinitiative.org/),
  436. [Orphanet](https://www.orpha.net/), [OMIM](https://www.omim.org/),
  437. [GeneCards](https://www.genecards.org/), [MalaCards](https://www.malacards.org/),
  438. [NCI cancer genetics resources](https://www.cancer.gov/about-cancer/causes-prevention/genetics),
  439. and the [COSMIC Cancer Gene Census](https://www.cosmickb.org/knowledgebase/cosmic-modules/)
  440. are source families agents may review, cite, and journal for disease,
  441. cancer-risk, and gene-context investigations.
  442. - [DrugBank](https://go.drugbank.com/),
  443. [PharmaProjects](https://pharmaintelligence.informa.com/products-and-services/data-and-analysis/pharmaprojects),
  444. and [PubMed](https://pubmed.ncbi.nlm.nih.gov/) support reviewed
  445. drug-target, mechanism, and primary-literature context when the agent records
  446. specific source-backed findings.
  447. ## How It Works
  448. Genomi exposes a small base MCP surface plus a dispatcher for specialized
  449. genomics tools. The host agent does the conversation; Genomi does the grounded
  450. lookup, Active Genome Index creation, evidence retrieval, and report assembly.
  451. 1. Connect an agent over MCP — see [the install steps](#or-if-you-prefer-the-old-school-way)
  452. above for the config snippet.
  453. 2. Give the agent a genome file when you want personal context.
  454. Genomi parses the file into an Active Genome Index: a local query substrate for
  455. variants, zygosity, quality, depth, filters, and callability context. Public-only
  456. questions do not require a genome file.
  457. ```json
  458. {
  459. "tool": "genomi.parse_source",
  460. "params": {
  461. "source": "<genome-file>"
  462. }
  463. }
  464. ```
  465. 3. Ask questions. The agent calls the smallest useful Genomi operation.
  466. Base operations such as `genomi.parse_source`, `genomi.describe_context`, and
  467. `journal.append_entry` are direct MCP tools. Capability operations go through
  468. `genomi.invoke` after the agent reads the matching `skills/<capability>/SKILL.md`.
  469. ```json
  470. {
  471. "tool": "genomi.invoke",
  472. "params": {
  473. "tool": "variant.resolve",
  474. "params": {
  475. "rsid": "rs429358"
  476. }
  477. }
  478. }
  479. ```
  480. 4. Inspect evidence, defaults, and limitations.
  481. Genomi results include structured evidence, source coverage, and
  482. `defaults_applied` where assumptions matter. Missing libraries, unavailable
  483. external sources, and background jobs return explicit statuses instead of being
  484. treated as negative evidence.
  485. 5. Remember.
  486. The Journal records observations, decisions, unresolved questions, and evidence
  487. links.
  488. ## Build With Genomi
  489. Genomi is open source and built for people who want AI agents to work with
  490. genomics responsibly: local-first, evidence-grounded, and honest about
  491. limitations. Use it to explore, explain, remember, and report on DNA questions
  492. without uploading the raw genome file.
  493. ## Status
  494. > [!WARNING]
  495. > **Experimental. Research and informational use only.**
  496. > Genomi is not a diagnostic device. It does not replace qualified clinical
  497. > review for diagnosis or treatment. Raw genome data stays on your machine
  498. > by design — but you are still responsible for how you share what comes out
  499. > of it.
  500. The schema, tool surface, and capability layout are still moving — pin a
  501. commit if you need stability across upgrades.
  502. ## License
  503. Genomi is released under the [Apache License 2.0](LICENSE).
  504. ## Citation
  505. If you use Genomi in research, publications, reports, benchmarks, demos, or
  506. derived tools, please cite the project using [CITATION.cff](CITATION.cff) and
  507. acknowledge Genomi where appropriate.
  508. ```bibtex
  509. @software{genomi2026,
  510. title = {Genomi: A Local Genomics Harness for AI Agents},
  511. author = {Zeng, Mingde and Zhou, Hongjian and Liu, Fenglin and Wu, Jinge},
  512. year = {2026},
  513. url = {https://www.genomiagent.com/},
  514. version = {0.1.0}
  515. }
  516. ```
  517. ## Contributing
  518. Issues and pull requests welcome. If you are reporting a bug, include the
  519. genome source format (VCF / gVCF / 23andMe / AncestryDNA / etc.), the
  520. operation you ran, and the structured error envelope the agent received —
  521. that is usually enough to reproduce.
  522. ## Acknowledgements
  523. Genomi owes a direct implementation debt to the
  524. [Personal Genome Project — Harvard Medical School](https://my.pgp-hms.org/public_genetic_data)
  525. public genetic data catalog.
  526. That same PGP-HMS public dataset also did the unglamorous work of letting
  527. Genomi support these provider shapes natively. Detectors, column quirks,
  528. header banners, archive wrappers, and provider-tagged VCF paths are
  529. sanity-checked against real PGP participant exports when the public catalog
  530. contains that format. Native 23andMe, AncestryDNA, MyHeritage,
  531. FamilyTreeDNA, Nebula, Dante, Sequencing.com, VCF, gVCF, BAM, and FASTQ
  532. coverage benefits directly from those examples; Living DNA and `.genome`
  533. remain supported formats, but the checked PGP-HMS public inventory did not
  534. include examples for those shapes.
  535. Thanks also to [GBrain](https://github.com/garrytan/gbrain), Garry Tan's
  536. OpenClaw/Hermes agent-brain project, for inspiration around making agent
  537. systems source-grounded, memory-aware, and useful from a single fetched
  538. documentation entry point.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.