Skip to content
heyaican

Released Mar 2026

Record sheet · No. 059

Blatant-Why

A protein-design campaign kit for Claude Code: prompt-defined agents write the model inputs, submit them to BoltzGen, Protenix or PXDesign on whatever GPU you have, and rank what comes back with a published interface score.

Source Submit a correction
Screenshot of Blatant-Why
Editor screenshot, 30 Oct 2026Blatant-Why ↗

What it is

Getting from a target protein to a list of antibodies worth synthesising is a chain of five or six separate programs, and the hard part is the wiring between them. Each one wants its own input format, its own environment and its own job queue.

One model wants a YAML of entities whose binding residues are numbered one way, the next wants a JSON of sequences, a third wants a PAE matrix read at the right cutoff, and each of them expects a different card.

Blatant-Why, which its author shortens to BY, packages that chain as a Claude Code project. Run the init command in an empty directory and you get 11 MCP servers, 21 agent definitions, 19 skills and 13 slash commands, all of them plain files, plus a CLAUDE.md that tells the model when to delegate to which agent.

Say design VHH nanobodies against PD-L1 and the orchestration does what a person would otherwise do by hand: query PDB, UniProt and SAbDab for the target, pick an epitope, write the BoltzGen or PXDesign input, submit it to a local GPU, a RunPod pod or Tamarind's cloud, refold every design with Protenix, compute ipSAE and ipTM from the predicted error matrices, scan the sequences for liabilities, and hand back a ranked table.

The generative work is not BY's. BoltzGen, Protenix and PXDesign are public models by other teams, installed separately. BY is the layer that drives them and keeps the campaign state. The repository description names those three and adds 200+ cloud tools, which is Tamarind Bio's catalogue rather than anything this repository ships.

Who built it

A GitHub account created on 2024-02-08 with 15 public repositories and 32 followers, whose profile reads Proteus Labs, links proteusbio.ai, and carries the bio Nature has time we have GPUs. He owns 168 of the repository's 169 commits; the other one is a stranger's fix merged in October. His other work is the same corner of the field: 001TMF/ProteinView, a Rust structure viewer with 342 stars, and 001TMF/harness-forge at 81. The PROTEUS_ prefix still on every environment variable in the code is the earlier name of this project.

How it is put together

The parts · 7

The organising idea is that the agent host is the runtime, and the repository is a set of instructions for it. Nothing in this project schedules work, holds a model in memory or runs a loop over candidates; Claude Code does that, and BY supplies four kinds of material for it to use. Prose: 21 agent definitions, 19 skills with their reference files, and a CLAUDE.md that states which agent runs in which order and which tools each may touch. Callable programs: 11 MCP servers whose 83 tools reach databases, compute backends and the campaign store. Numeric code: the ipSAE implementation, the composite ranking, and the liability, charge and developability screens. And state: a directory per campaign under .by/campaigns, written as JSON and Markdown by the servers and read back by the agents. The pipeline is therefore a chain of files, which is what makes a campaign resumable and inspectable after the fact, and also what makes it dependent on the model following instructions rather than on a scheduler enforcing them. Everything expensive is external: the three engines are installed by the user, called through their own command lines, and never bundled, so the repository stays small and the first campaign stays slow to start.

templates/.claude/agents
21 Markdown agent definitions with YAML front matter: a name, a one-paragraph role, a tool allowlist and, for the design agent, an explicit denial of the lab-submission tools. These are the unit of delegation, and the allowlist is enforced by Claude Code rather than by any code in this repository.
templates/.claude/skills
19 skills, each a SKILL.md plus a references/ directory of rules and a scripts/ directory of helpers. The three engine skills teach one pattern each: write the input file, run the upstream binary, parse the output CSV. The rest cover campaign management, scoring, screening, epitope analysis, failure diagnosis, HPC deployment and a hypothesis debate.
templates/.claude/mcp_servers
The callable layer: 11 self-contained Python servers run as uv run --script, 83 tools in total. Four reach databases (PDB, UniProt, SAbDab, a research server), three reach compute (local and SSH, a unified cloud abstraction, Tamarind), and four hold the campaign: state, screening, knowledge and the gated lab submission.
src/proteus_cli
The Python package, also exposed as a proteus console script: the ipSAE implementation, a screening package with alignment, cross-validation, developability, diversity, liabilities, naturalness, Pareto fronts and a contact-count stand-in for shape complementarity, plus campaign state, cost estimation, active learning and an SSH runner.
src/init-cli
The npm half: a TypeScript scaffolder that checks for uv and Python 3.11, copies the templates, writes .claude/settings.json, registers every MCP server with claude mcp add -s project, prompts for keys and verifies the registration. This is all the published npm package contains.
templates/CLAUDE.md, templates/.by/config.json and templates/.claude/hooks
The orchestration rules, the compute policy and the gates. CLAUDE.md names the mandatory five-agent chain and forbids silent provider fallback; config.json sets local as the default provider with a priority list; hooks.json installs a session-start loader, two post-tool scripts and a pre-tool safety gate on the lab submission call.
templates/.claude/scripts
Four hook programs: an env loader, a status line, a campaign tracker and safety-gate.js, which reads an approval file under .by/lab/ and blocks the lab tool when it is missing or older than five minutes.

Choices, and the alternative

  • Make the agent host the runtime over shipping an orchestrator of its own

    The one Python file that tries to dispatch agents, orchestrate_debate.py, calls Task behind a try/except NameError and writes stand-in proposals when that name is absent, with the real call left as a comment. Delegation works because CLAUDE.md tells the model to use the host's subagent tool. The trade is visible: there is no queue to inspect when a stage stops.

  • Require the user to install the three engines over bundling or vendoring the models

    plugin-manifest.json maps each engine to an environment variable and an upstream URL, and nothing in the tree is a checkpoint; the licence headers, the weights and the CUDA requirements all stay with the upstream projects. The cost lands on the first campaign, which needs three environments and about 50 GB of weights before it produces a design.

  • Rank with a published metric and fixed weights over training a re-ranker on campaign outcomes

    ipSAE is a formula from another repository with its provenance in a comment, and the composite weights are three constants with a written rationale. The one learned component is a 100-tree random forest over five scores, trained on a campaign's own designs, which is small enough to read and was small enough to contain a leakage bug for five months.

  • Keep campaign state in files on disk over a database or a hosted service

    The campaign server reads and writes JSON and Markdown under .by/campaigns, agents pass each other paths, and the resume skill walks the artifact checklist to find where a campaign stopped. A finished campaign is a directory that can be copied, diffed and read without the tool, which matters for something a lab notebook may have to reference.

  • Gate the lab order three separate ways over a single confirmation prompt

    A PreToolUse hook reads an approval file with a five-minute expiry, the campaign state carries its own approved flag, and the Adaptyv tool asks for a confirmation code. Ordering synthesised proteins is the only step in the pipeline that spends money that cannot be refunded, and it is the only step with that much machinery around it.

Read fromREADME.md, CLAUDE.md, plugin-manifest.json, package.json, pyproject.toml, .env.example, docs/LOCAL_GPU_SETUP.md, the 21 files in templates/.claude/agents/, the 19 skills under templates/.claude/skills/ including by-scoring/references/scoring-pitfalls.md and composite-score.md, by-campaign-manager/references/cost-model.md, by-hypothesis-debate/scripts/orchestrate_debate.py, the 11 servers under templates/.claude/mcp_servers/, templates/.claude/hooks/hooks.json, templates/.claude/scripts/safety-gate.js, templates/.by/config.json, the three example campaign configs, src/init-cli/, src/proteus_cli/, tests/, and the assets directory, in 001TMF/blatant-why at master, read 2026-10-31.

Build log

7 stages
  1. 01

    What a biologics design campaign is, and where the agent sits

    The thing being designed is a protein that sticks to one chosen patch of a larger protein. For an antibody or a nanobody the computational output is a sequence plus a predicted 3D structure of the pair; whether it actually binds, and how tightly, is a question for a lab. Every number the pipeline produces before that is a prediction. The chain is stable across this field. Fetch the target structure from the PDB and its sequence and annotation from UniProt, then look for known binders in SAbDab, the Structural Antibody Database. Choose an epitope, meaning which residues on the target the binder should sit on, because a binder pointed at the wrong face is a wasted campaign. Generate: this is where the heavy models work, either a diffusion model that proposes backbones and then assigns sequences, or a de novo binder designer. Refold each proposed complex and read the model's own confidence out of it. Score the interface, filter the sequences for things that make a molecule hard to manufacture, and rank what is left. Order the survivors from a synthesising lab and feed the readouts back. BY is the glue across those steps and nothing more. It never folds anything itself and holds no weights. What it holds is the instructions for each step, the small programs that compute the scores, the state of a campaign between sessions, and the rules for which agent may call which tool. The measurements in this record come from the tree. git ls-files lists 261 files and 4,003,487 bytes. Of those, 116 Markdown files carry 1,270,053 bytes and 20,357 lines, and 104 Python files carry 1,090,662 bytes and 25,920 lines. GitHub's size field reports 12,003 KB, which counts what the packfile stores. The Markdown outweighs the Python in the sense that matters here: the agents and skills are prose instructions to a language model, so the prompts are a larger part of the product than the code is.

  2. 02

    Three public models, one borrowed number, and a link that 404s

    BoltzGen is HannesStark/boltzgen: MIT, created 2025-10-26, 1,090 stars, installable with pip install boltzgen, and described by its own README as a design tool with a diffusion stage followed by inverse folding and an analysis pass. BY uses it for antibodies, nanobodies and de novo binders. Protenix is bytedance/Protenix: Apache-2.0, 2,098 stars, and the README's model table gives 368 M parameters for protenix_base_default_v1.0.0, the AlphaFold3-class model BY's skill documents. BY calls it to refold a complex and to read out ipTM, pTM and pLDDT. PXDesign is bytedance/PXDesign: Apache-2.0, 272 stars, created 2025-12-04 and last pushed 2025-12-31. Its README describes a diffusion generator, PXDesign-d, paired with Protenix and AF2-IG as confidence models, and says that across seven targets it delivers 17-82% nanomolar hits on six. That sentence is where BY's repeated 17-82% hit rates comes from, and it is a claim about the model, not a measurement of any campaign BY has run. The fourth name is the scoring metric. ipSAE is DunbrackLab/IPSAE, MIT, 282 stars, and src/proteus_cli/scoring/ipsae.py reimplements it: take the interchain block of the predicted aligned error matrix, keep per-residue minimum PAE, clamp the interface residue count at 19 before computing the d0 normaliser, run the TM-score kernel, average over residues below the cutoff, do it in both directions, and report the smaller of the two. The default cutoff is 10 Å, which is right for Protenix and AlphaFold3 output and wrong for AlphaFold2, a distinction the project's own scoring notes make. What 200+ cloud tools counts is Tamarind Bio. The README says Tamarind provides access to 200+ structural biology tools; the unified cloud server's docstring says Tamarind Bio cloud API (free tier, 200+ tools); and the tamarind server's list tool says it returns 226+ tools. BY's own surface onto that catalogue is 10 tools on the tamarind server and 8 on the cloud server, most of them submit, poll and download. The catalogue is real and it is somebody else's, it needs a Tamarind key to reach, and GET https://app.tamarind.bio/api/tools returns 400 without one, so this record cannot count it independently. One link in the README does not resolve. The local-GPU section says git clone https://github.com/jostorge/boltzgen, and that repository returns 404; the account jostorge has two public repositories and neither is BoltzGen. plugin-manifest.json and the boltzgen skill both point at HannesStark/boltzgen, which is where the model actually lives.

  3. 03

    What "multi-agent orchestration" is made of here

    The agents are 21 Markdown files under templates/.claude/agents/, each with YAML front matter naming the agent, describing it, and listing the tools it may use. by-design gets Read, Bash, Grep, Glob, Write plus five wildcard MCP scopes and is explicitly denied the Adaptyv scope; by-lab is the agent that carries the lab permission. Nothing in the Python package reads those files. Claude Code does, and the allowlist is enforced by Claude Code. The rules that make it a pipeline are in templates/CLAUDE.md, which states that agent delegation is mandatory for campaigns and names the chain: by-research writes target_report.json, by-campaign writes campaign_plan.md, by-design writes design_summary.json, by-screening writes screening_results.json, by-verifier writes verification_report.md. Each stage is a file on disk that the next stage is told to read, which is what makes /by:resume possible at all: the resume protocol walks the checklist of artifacts and restarts at the first missing one. The callable half is 11 MCP servers exposing 83 tools between them, counted from the @mcp.tool() decorators: screening 14, campaign 14, tamarind 10, cloud 8, local_compute 8, knowledge 6, pdb 5, research 5, adaptyv 5, uniprot 4, sabdab 4. Each server is a single Python file with a PEP 723 header, run as uv run --script, so registration is one claude mcp add per directory and there is no build step for them. There is exactly one Python file that tries to spawn agents. templates/.claude/skills/by-hypothesis-debate/scripts/orchestrate_debate.py is 571 lines. It builds three directives (conservative, aggressive, diverse), then calls _spawn_agent_task, whose body is try: Task except NameError: followed by writing a mock proposal, with a comment where the real dispatch would go. The reflection agent that is supposed to rank the proposals is also a comment, and the ranking that actually runs is a weighted sum of four axes computed from the proposals' own fields. The skill's README calls this a 3+1 agent topology. So the orchestration that runs is natural-language instruction plus file contracts, and the dispatcher is the agent host's own subagent tool. That is a real mechanism, and it is why a stalled campaign leaves a transcript rather than a job queue. It is also why the delegation can be skipped: it is a rule in a text file, and several skills repeat do not do this inline because the rule does not enforce itself.

  4. 04

    The scoring is where the hand-written code is

    Four things in this repository compute something rather than describe it. Interface score. compute_ipsae takes a PAE matrix and two chain masks, computes the d0 normaliser from the number of interface residues with a floor at 19, scores each residue pair with 1 / (1 + (pae/d0)^2), averages over the residues that passed the cutoff, and returns both directions plus their minimum. The same code exists twice, once as a module and once inlined into the screening server, which is a maintenance cost the tree carries rather than hides. Composite ranking. 0.50 * ipSAE_min + 0.30 * ipTM + 0.20 * (1 - min(high_severity_liabilities / 5, 1)), with the weights and the liability cap written down in by-scoring/references/composite-score.md next to the reasoning for each. Sequence screening. The liability scan is a set of regular expressions: NG, NS, NT, NA for deamidation at three severities, DG, DS, DT for isomerisation, every methionine as an oxidation risk, an odd cysteine count as free cysteines, and N-X-S/T as a glycosylation motif. Net charge is Henderson-Hasselbalch over a seven-entry pKa table. Developability is the hydrophobic, proline and glycine fractions plus those two outputs. Naturalness is AbLang2's pseudo-log-likelihood when the package is installed and an error object with an install hint when it is not. Interface geometry. screen_shape_complementarity does not compute a shape-complementarity statistic. It parses the structure with BioPython, counts atom pairs within 8 Å across the two chains, and returns contacts, interface residue counts and a contact density; the comment above it says Simplified. The name is the one place in the tree where a label is more ambitious than the code. The best technical writing here is by-scoring/references/scoring-pitfalls.md, which knows where ipSAE stops working: the d0 clamp at n0 = 19 makes tiny interfaces score near zero regardless of geometry, a single seed on a flexible CDR-H3 loop can move ipSAE by 0.1 to 0.2, and a 15 Å cutoff on Protenix output inflates scores by 0.05 to 0.1. Those are the right worries, stated by somebody who has hit them. The citation behind the 0.50 weight is where the record has to slow down. composite-score.md attributes it to The Dunbrack 2025 meta-analysis (n = 3,766 published binders), which found ipSAE_min the best single predictor of experimental success. There is a meta-analysis with that sample size, and it does conclude that AF3-derived ipSAE beats ipAE and ipTM, with a 1.4-fold average-precision gain over ipAE. The authors are Overath, Rygaard, Jacobsen, Brasas, Morell, Sormanni and Jenkins (bioRxiv, 2025-08-14); Dunbrack wrote the ipSAE method itself, which is a different paper. The paper also reports that adding Rosetta ΔG/ΔSASA and interface shape complementarity improves on ipSAE alone, and neither appears in BY's composite. The weight survives on its own merits; the attribution is to the wrong author and the missing features are the paper's actual recommendation. The same document reports Internal BY validation on 1,200+ refolded designs with Spearman correlations of 0.62 for ipSAE, 0.41 for ipTM and 0.18 for pLDDT against experimental Kd. No dataset, script, table or reference in the tree supports those numbers. This record carries them as the author's claim.

  5. 05

    Can you run it, and what it asks you to install first

    On npm there is one version, blatant-why@0.1.0-beta, published at 2026-04-03T23:54:37Z, downloaded 19 times in the thirty days ending 2026-10-29. PyPI has no package of that name. GitHub has 0 releases and one tag, v0.1.0-beta. The package's files list is dist/, templates/, the README and the licence, and its single binary is named by, while the README's quick start says npx blatant-why init. What that binary does is scaffold. runInit checks for uv and Python 3.11, copies the template tree into the current directory, writes .claude/settings.json while stripping any mcpServers key out of it, shells out to claude mcp add -s project once per MCP directory, prompts for API keys, appends to .gitignore, creates .by/campaigns, and lists the servers back with claude mcp list. There is no solver in the npm package. There is no continuous integration: the repository has no .github directory. Tests exist and are not wired to the publish: 128 def test_ functions across 12 Python files, plus three shell scripts, of which npm test runs two. The Python side needs Python 3.11 or newer, click, pydantic, rich, pyyaml, numpy, biopython, httpx, mcp and scipy; scikit-learn, fair-esm and ablang2 are optional extras, and the features that need them degrade to an explanatory error. The expensive requirements are outside the repository. Local mode needs an NVIDIA GPU with at least 24 GB of VRAM, the project's own setup guide recommends A100 or H100 and calls an RTX 4090 the minimum, CUDA 12.1, and roughly 50 GB of model weights, and the user installs all three engines. PXDesign asks for CUTLASS and custom kernels, and its own README recommends its web server instead of a local install. The cheap path is Tamarind: a free key, ten jobs a month, and no GPU, at the price of uploading the target. A third path is RunPod, Modal or SSH to a machine you already have, and a fourth is the lab, where the example configs put Adaptyv at $175 per variant with a cap of 20 candidates. The honest summary of the install is that the npm package is a small TypeScript scaffolder, the Python package is the scoring library, and everything generative is a git clone and a conda environment away.

  6. 06

    119 stars, and the shelf it is standing on

    The reading was taken at 2026-10-30T17:34:54Z: 119 stars, 11 forks, 1 watcher, 2 open pull requests, last push 2026-10-16T00:12:10Z. Against the models it drives, the number is small: Protenix 2,098, BoltzGen 1,090, PXDesign 272, IPSAE 282. In GitHub's antibody-design topic, which returns 59 repositories, it sits fifth behind BoltzGen, Rosetta at 481, AntiFold at 177 and dyMEAN at 135, and ahead of MEAN at 112 and AstraZeneca's DiffAbXL at 100. In the narrower niche it occupies it is first, and the niche is almost empty: a search for antibody design agent in repository descriptions returns four repositories, three of them with one star or none, and binder design agent returns eighteen with T-REX at 24 next after this one. The nearest thing to a peer built by a company in this space is adaptyvbio/protein-design-skills, at 173. Behind the stars is a short, dense history. master carries 169 commits from two accounts: 168 from 001TMF and one from liutmelody. By month that is 158 in March 2026, 10 in May and 1 in October, and by day it is 15 on 2026-03-04, then 36, 57 and 50 on 2026-03-23, 24 and 25, which is 143 of the total in three days. The first commit is dated 2026-03-04T13:30:01Z, nineteen days before GitHub created the repository at 2026-03-23T18:54:59Z, so the work existed locally first. Then 9 commits on 2026-05-20 for a skills pass, and nothing until the last commit, 2026-10-16T00:12:10Z, which is the merge of somebody else's two-file fix. 153 of those commits carry a co-author trailer, and 152 of the trailer lines name a Claude model: 128 Claude Opus 4.6, 15 more of the same model under a different address, 7 Claude Opus 4.7 and 2 unversioned. One names Codex CLI. Commit subjects run 64 feat, 62 fix, 10 docs, 8 chore, 5 test. There are five issues and pull requests in total: three closed, and two open, one of them a six-agent security audit filed two days after launch with no comments, the other a branch that swaps the Tamarind backend for Modal. What the stars did not come with is attention. The repository was created the same day Latent Labs announced an autonomous drug-design agent (2603.29727), and the README's second paragraph is aimed at that category. A Hacker News submission on 2026-03-25 finished at 3 points and 2 comments, one of them a reply from proteus-design about how BoltzGen's reported success rate compares.

  7. 07

    The part the repository does not say

    There is no limitations section. The README has no sentence saying that a ranked design is a prediction, no note that a hit rate requires a wet lab, no disclaimer about clinical use, and no list of what the pipeline cannot do. For a tool whose output is a molecule somebody might pay to synthesise, that is the largest gap in it. What it has instead is a joke where the evidence should be. The only performance graphic in the README is a bar chart of time to complete an antibody design campaign, three bars labelled weeks, hours and minutes?, with the x-axis reading painful, vibes-based and 56x faster!!!. Its caption is Source: trust us bro; its footnote reads Y-axis: conveniently omitted · Baseline: "independent expert time estimates" · n = 3 · Peer reviewed: no. The author is telling the reader not to believe it, which is more honest than the alternative and still not a description of what the agent does well. The safety and quality gaps are written down in places a reader reaches late. The author's own six-agent security audit is pull request #1, open since 2026-03-25 with no comments, and it reports 8 critical, 9 high, 12 medium and 8 low findings, naming SSH command injection, path traversal in exports, unsafe numpy pickle deserialization and unpinned Python dependencies. np.load(..., allow_pickle=True) is still in ipsae.py at score_npz. The lab submission is the one step with three gates around it, a hook reading an approval file with a five-minute expiry, a campaign flag and a confirmation code, which suggests the author thought about the irreversible step and about the rest less. The most instructive defect is the one a stranger found. liutmelody opened a pull request on 2026-05-04 titled fix data leakage bug: remove ipsae from RF features since it's the target, with the body this looks cool! i don't think ipsae should be in the random forest features though since it's the target. lmk if i'm off base though. The random forest is the campaign optimizer's active-learning step, and it was trained on five other scores to predict ipSAE while ipSAE was one of its own inputs. The fix is two files and five changed lines, and it merged on 2026-10-16, five months later. Nothing in the tree is a wet-lab result. examples/ holds three config.yaml files for PD-L1 and TNF-α campaigns and no output. The 66% figure a reply from proteus-design gives for BoltzGen on novel targets lives in that Hacker News comment, not in the repository. And the project's own open pull request #5 says what comes next: strip Tamarind, move to Modal and local compute, per the move to an own-the-stack, kimi-only harness. The 200+ in the description and the Claude Code dependency are both on that list.

What they would tell you

  • The stars measure the wrapper idea, not the science. At 119 this is fifth of 59 repositories in GitHub's antibody-design topic and first among the agent wrappers in the niche, and it is smaller than every model it drives: Protenix at 2,098, BoltzGen at 1,090, PXDesign at 272, IPSAE at 282. The nearest company-built peer, Adaptyv's own protein-design-skills, has 173.
  • The 200+ in the repository description belongs to Tamarind Bio. BY exposes 10 tools on its Tamarind server and 8 on its unified cloud server, mostly submit, poll and download, and the catalogue behind them needs a key and a free tier of 10 jobs a month. The project's own open pull request #5 proposes dropping Tamarind for Modal and local compute, which would make the description wrong rather than merely borrowed.
  • Multi-agent orchestration resolves to Markdown files and the host's subagent tool. The 21 agents are prompts with tool allowlists, the pipeline is a list of files each stage writes for the next, and the only Python dispatcher writes mock proposals when the runtime name is missing. That design works, and it means a stalled campaign leaves a conversation to read rather than a queue to inspect.
  • The scoring code is real and better documented than most projects of this size. scoring-pitfalls.md names the three ways ipSAE misleads, the d0 clamp below 19 interface residues, a single seed on a flexible loop, and a 15 Å cutoff on Protenix output, and each comes with the correction. The composite's 0.50 weight is attributed to the wrong paper, and the two extra features that paper recommends, Rosetta ΔG and shape complementarity, are not in the composite.
  • Nothing here has been validated against a wet-lab result the project published. examples/ holds three campaign configs and no output, the README has no limitations section, and the Internal BY validation on 1,200+ refolded designs behind the Spearman correlations has no dataset, script or table in the tree. The one external validation cited, the 3,766-binder meta-analysis, is about the metric rather than about this tool.
  • The leakage bug is the instructive one. For five months the campaign optimizer trained a random forest to predict ipSAE with ipSAE among its own features, which is the kind of error a single review pass catches and no test does. A stranger caught it in May, the fix is five lines in two files, and it merged in October. Whatever else the learning layer is, it has not been audited.
  • The barrier is setup, not code. A local campaign needs a 24 GB NVIDIA card, CUDA 12.1, about 50 GB of weights and three upstream installations, one of which wants CUTLASS and recommends its web server instead. The npm package is a scaffolder of 480 lines of TypeScript, the Python package is the scoring library, and everything that generates a molecule is somebody else's repository cloned by hand.

Adjacent records

All records →

No. 127

Lemmalog

A Rust Datalog engine that treats agent memory as a deductive database, not a bigger vector store: facts asserted at the extraction boundary, stratified rules deriving closures and temporal views, provenance back to the source episode on every derived fact, and views maintained one epoch at a time — served to Claude Code and Kimi CLI as twelve MCP tools.

No. 080

Engram

A learning engine that installs into a coding agent: a curriculum architect breaks a topic into a first-principles concept map, a tutor makes you predict, attempt and explain before it explains, a blind assessor grades your verbatim free recall and writes a receipt for every verdict, and a deterministic FSRS-4.5 core in one Python file decides when each concept comes back, with explorable HTML built only for the concepts whose content rewards manipulation.

No. 140

Agents Universe

An open-source agent platform that keeps one project context shared by everyone working in it. Agents read the whole knowledge base when a project is opened and write what they learn back into the same files while they work; knowledge is Markdown on disk with a database index behind it, and there is no embedding model or vector search.