SKILLFUL ALHAZEN Technical Seminar · Altos Labs

</> A WALKTHROUGH

# Skillful
Alhazen

A TypeDB‑powered, ontology‑backed notebook for agentic curation — one framework, many domains.

</> framework </> ontology </> agentic-memory </> biomedicine

Brief

"The duty of the man who investigates the writings of scientists, if learning the truth is his goal, is to make himself an enemy of all that he reads, and, applying his mind to the core and margins of its content, attack it from every side."

— Ibn al‑Haytham · 965–1039 AD

Speaker Gully Burns
Role Architect & sole engineer
Date May 7, 2026
02·ORIGIN From a literature corpus to a general framework

Origin

## A literature‑curation problem,
generalized into a notebook for any domain.

2018 — 2022

Literature curation

Hand‑curated metadata pipelines for biomedical papers. Brittle, expensive, single‑domain.

CZI

Alhazen v1

First pass: heavy framework, bespoke runtime, single biomedical use‑case baked in.

2025 — 2026

Skillful Alhazen

Reimagined around Claude Code, TypeDB 3.x, and a skills marketplace. Domain becomes a plug‑in.

Today

CAIS 2026 + 6 demos

Same framework now powers career, journalism, and rare‑disease curation skills.

trajectory single‑domain pipeline → heavy framework → skill marketplace
03·PROBLEM What agentic curation actually demands

The thesis

## Agentic curation needs structured memory,
not Markdown sprawl.

— what most stacks do

Dump everything to MD files or an opaque RAG blob. Fine for chat. Useless when you need to ask which and why.

— what we do

Typed entities, typed relations, typed notes — persistent across sessions, queryable across skills.

— the lesson, recalled

Bioinformatics taught us data hygiene 20 years ago. Let's not forget it now.

04·THREE LAYERS Agent · Ontology · Skills

The shape of the system

## Three layers. Clean separation. Same skills, two runtimes.

AGENT

### Claude Code & OpenClaw

You talk; the agent curates. Claude Code for interactive work, OpenClaw for a persistent local or VPS service.

runtime layer

ONTOLOGY

### TypeDB 3.x

The schema defines what the agent reasons about. The data is what it has learned so far. Persistent across sessions.

memory layer

SKILLS

### Domain modules

A typed schema namespace, a Python CLI, agent instructions — optionally a dashboard. Self‑contained directory.

extension layer

key move The agent doesn't know the schema. It calls CLI scripts that operate on it. Schema and reasoning stay decoupled.
05·ARCHITECTURE System overview

Boxes & arrows

## Operator → agent → skill → typed memory.

Operator

You.

Researcher, curator,
analyst.

Agent runtime

Claude Code

interactive · skills via .claude/skills/

OpenClaw

persistent service · Mac mini / VPS

Evolution loop

Schema gaps

PostToolUse hook
↓
file‑schema‑gap CLI
↓
GitHub issue → PR
↓
schema.tql merged

Skill dispatch

scientific‑literature

SKILL.md · .tql · CLI

jobhunt

SKILL.md · .tql · CLI

dismech

SKILL.md · .tql · CLI

+ skill

git clone · register

Typed memory + spillover

TypeDB 3.x

typed entity hierarchy · skill‑namespaced

Artifact cache

~/.alhazen/cache/

Qdrant

semantic search · scilit

06·NOTEBOOK MODEL One identifiable‑entity hierarchy

The notebook model

## One typed hierarchy.
Three branches.

Everything inherits from alh‑identifiable‑entity. The hierarchy is the part that does not change per skill — skills extend the leaves with namespaced sub‑types.

DOMAIN Real‑world objects — papers, diseases, genes, jobs, people.
COLLECT Typed sets — corpora, search campaigns, case files.
CONTENT Artifacts (raw), fragments (extracted), notes (Claude's analysis).

Schema

</> alh-identifiable-entity

    // abstract root — id, name, description, provenance
    alh-identifiable-entity
    ├── alh-domain-thing          // real-world objects
    │   ├── agent             // person · ai-agent
    │   │   └── person        // linkedin · email · bio
    │   ├── alh-role          // anti-rigid (BFO/UFO)
    │   ├── organization
    │   └── interaction       // meeting · email · interview
    ├── collection                 // typed sets
    │   ├── scilit-corpus
    │   ├── jhunt-search
    │   └── apm-case-file
    └── alh-information-content    // content-bearing
        ├── artifact          // raw — pdf · html · email
        ├── fragment          // extracted piece
        └── note              // Claude's analysis

local_resources/typedb/alhazen_notebook.tql

07·SKILLS The unit of extension

Anatomy of a skill

## A skill is a self‑contained directory — and a marketplace entry.

Anatomy

    skills/jobhunt/
    ├── SKILL.md            // triggers · workflows · commands
    ├── skill.yaml          // metadata · namespace prefix
    ├── schema.tql          // TypeDB extension
    ├── jobhunt.py          // the verbs Claude calls
    ├── quality-checks.yaml
    └── dashboard/            // optional Next.js

Single source of truth: skills-registry.yaml. Core skills with path:, externals with git:. make build-skills resolves the registry, drops symlinks, loads schemas.

Contract

Every skill contributes four things:

① A typed schema namespace — every type prefixed. ② A Python CLI — verbs the agent invokes. ③ Agent‑readable SKILL.md — triggers, workflows, commands. ④ Optional dashboard — Next.js components wired at build.

Marketplace pattern

Skills live in their own git repos. To add one: git, register, build. No platform, no plugin runtime, no SDK — just a directory and a CLI.

08·HARD PROBLEM · 1 Schema as a living artifact
01

Hard problem · one

## The schema can't be frozen — the agent learns new things.

Standard agent stacks treat "I can't represent this" as a silent skip. We treat it as the most important signal in the system.

Two failure modes

EXECUTION | Tool crash · empty result · API down → standard error log + retry
SCHEMA GAP | TypeDB write rejected · concept has no type → filed as a structured GitHub issue

The evolution loop

[1] Claude writes to TypeDB → error code [SYR1] [TYR01] [FEX1]
[2] PostToolUse hook detects the code, prompts [SCHEMA-GAP-HINT]
[3] file-schema-gap CLI: dedupes, routes to repo, opens issue
[4] gap-triage.yml labels by severity / phase / skill
[5] Local fix · validate against running TypeDB · draft PR · human merge

Schema gaps are signal, not noise. They are how the graph grows from use, not from upfront design.

09·HARD PROBLEM · 2 A lightweight runtime, on purpose
02

Hard problem · two

## Don't build an agent platform. Use the one you already pay for.

— constraints

- ·Existing Claude license — keep token cost low
- ·One engineer — maximum flexibility, minimum maintenance
- ·Deploy must be git clone && make build
- ·No platform lock‑in

— moves

- ·Claude Code is the agent runtime
- ·Skills are git repos · marketplace pattern
- ·Same skill bundle wraps in OpenClaw for persistent service
- ·Three deploy targets: laptop · Mac mini · VPS

Tradeoff accepted

Less control over the agent loop. We don't own the orchestrator — a Claude Code change can move things under us.

Win banked

~10× less code to maintain. Onboarding a new skill is one PR. Iteration speed is the moat.

10·HARD PROBLEM · 3 Notebook memory over Markdown sprawl
03

Hard problem · three

## Prove the notebook is actually better than what people already do.

Markdown notes

Drift & duplicate.

Same fact in three files, slightly different. No way to ask “which”.

RAG only

Opaque blob.

Useful for retrieval, useless for audit. Can't introspect what's in there.

TypeDB notebook

Typed & queryable.

Multi‑hop questions across skills. Provenance on every claim.

Example query — only possible because the schema is real

    // "Every contact who flagged a skill gap, grouped by funding stage."
    match  $c isa jhunt-contact,        has name $cname;
           $g isa jhunt-skill-gap-note,  has content $gtxt;
           $co isa jhunt-company,        has stage $stage;
           (mentioner: $c, mention: $g) isa jhunt-mention;
           (employee: $c, employer: $co) isa alh-works-at;
    fetch  $cname; $stage; $gtxt;

RAG & MD are still here when they're the right tool — the notebook adds structure on top, not instead.

11·SKILL MARKETPLACE Six domains, one shell

What's deployed

## Six skills, three really different domains, the same notebook underneath.

Skill | Type | Domain | What it does | UI
--- | --- | --- | --- | ---
scientific-literature | external | Biomedical | Multi‑source literature search · PubMed · Europe PMC · OpenAlex · semantic search via Voyage AI + Qdrant | —
alg‑precision‑therapeutics | external | Rare disease | Investigate mechanism of harm and therapeutic landscape from a MONDO diagnosis | ✓
dismech | external | Disease mechanisms | Browse the DisMech knowledge graph — 750+ curated mechanism entries | —
literature-trends | external | Research analysis | Trace how explanatory hypotheses evolve over time in a tagged corpus | —
jobhunt | external | Career | Track positions and engagements · fit analysis · skill‑gap identification | ✓
they‑said‑whaaa | external | Journalism | Track public‑figure consistency — extract claims, detect contradictions across sources | ✓

Plus four core skills: </> typedb-notebook </> web-search </> curation-skill-builder </> tech-recon
12·IN PRACTICE A dossier in the wild

In practice

## A dossier is just a render of typed entities.

Position · contact · interview · fit‑analysis‑note — all live in TypeDB. The dashboard is one of the skill's optional contributions. Same backend powers the dismech mechanism browser and the scientific-literature corpora views.

POS jhunt-position
BRIEF jobhunt-cc-brief-note
TALK jobhunt-interaction-note
FIT jobhunt-fit-analysis-note
[ screenshot · jobhunt opportunity dossier ]
replace with: dashboard render at 1240×1700 — Augura Health position
13·OUTCOMES Where we are · honest lessons

Outcomes

## A paper, working demos, and three honest unfinished things.

Recognition

CAIS

Accepted at CAIS 2026.

ACM Conference on Agents and Agent Systems.

Working demos

6 skill demos

Across biomedicine, careers, journalism — three deploy targets, one codebase.

Adoption surface

3 runtimes

Claude Code · OpenClaw on Mac mini · OpenClaw on a hardened VPS.

Honest lessons — open work

Schema migration

When an attribute type changes, existing data needs migration. Today: re‑ingest. Need a real path.

Concurrent gap PRs

Two open gap fixes can touch the same entity. No tooling to detect the conflict yet.

Proposed vs. committed

All schema changes go straight to schema.tql. Want a real intermediate state.

14·Q & A Open questions for the next 40 minutes

Q & A · 40 min

## Where would you
push this?

Three areas I want to argue with you about — please be brutal.

①

Domain coverage at Altos

What does this notebook look like sitting under a real cell‑programming or rejuvenation workflow?

②

Schema governance at scale

When twenty skills share the core hierarchy, who arbitrates? What's the review cadence?

③

Notebook ↔ lab memory

Where's the boundary between agent memory and the systems of record — LIMS, ELN, sequencing pipelines?