phil-OKF is a skill for AI agents that turns any question into a single self-contained HTML page: minimal, white, research-paper style, every claim tagged to a source that resolves. The whole skill is one small bundle — an eight-step workflow, a domain classifier, a page template, and twelve study domains — and each file is read only when the depth of the question needs it.
Open a sample output ↗Editors and chat views each ask for one thing — a folder, a link, or plain text — so the skill ships in all three shapes. A skill agent opens SKILL.md and walks the bundle from there; a browsing model needs only the link to philosopher.md, which contains the whole skill in one file and does the rest on its own; anything without network is handed the prompt below [SKILL].
| Your tool asks for | Give it |
|---|---|
| A folder (Claude Code, opencode, Cursor, Codex) | npx skills add frypan05/philosopher-OKF (no git, Node 22+, installs into whichever agent you have), or clone this repo where your skills live |
| A URL (ChatGPT, Gemini, Claude with browsing) | github.com/…/blob/main/philosopher.md — say "follow this, make a page about: …"; the raw URL works the same for plain fetchers |
| Text (a model with no network) | The prompt below, or the repository ZIP from GitHub's Code menu |
A rules file (AGENTS.md, project docs) | For explanations, follow philosopher-okf/SKILL.md. |
Copy the skill into your chat, or into your code editor's skills folder and you're done.
You are Philosopher, a teaching engine. Open https://github.com/frypan05/philosopher-OKF/blob/main/philosopher.md and follow it exactly — it contains everything: the workflow, the page template, and the domain cards. If you cannot open URLs, ask me to paste philosopher.md. Reply with the file path only, or one HTML code block if you cannot create files. My question: <your topic>
OKF — the Open Knowledge Format — is plain Markdown with YAML frontmatter: one folder of typed files, no SDK, no build step, readable by any model that can open a file. This repository is a conformant bundle: okf/index.md declares okf_version at the root, every file carries a type, and scripts/validate.sh checks the rules and the links [OKF].
The format is why one skill serves every surface — a skill agent walks the folder file by file, and philosopher.md flattens the same bundle into a single file for chats that cannot fetch several [SKILL].
Plain Markdown. No SDK. Any model can read it.
The agent classifies the question to a single primary domain, loads only the files that depth requires, researches inside fixed caps, and writes the whole page in one file-creation call [Workflow]. The chat reply is at most two sentences — the path and what the page covers — never the page itself [Workflow]. Sources that were not retrieved this session are never cited: a page with three correct references beats a page with twelve doubtful ones [Source policy].
One file. White theme. No fabricated sources.
Brief questions read the template and a five-line Quick card from one domain file; deep questions add the source policy, the depth policy, the knowledge-graph method, and the full domain file [Load table]. The same row carries the research caps and the size budget for the page it produces [Depth budgets].
| Depth | Reads | Searches / fetches | Page budget |
|---|---|---|---|
| brief | template + domain Quick card | 2 / 0 | 250-400 words, 2 refs |
| standard | plus source and audience policy | 4 / 2 | 700-1100 words, 5 refs |
| deep | plus graph method, full domain | 8 / 4 | 1500-2500 words, 10 refs |
Four things consume context in a run: the bundle files it reads, the sources it fetches, its own reasoning, and the HTML it writes. The ceiling over all four is not one number — it follows the depth your words ask for [Depth budgets], defaulting to standard when the question says nothing [Defaults].
| What you ask for | Depth | Whole-run budget |
|---|---|---|
| "quick", "what is" — a fast answer | brief | about 12k tokens |
| A normal question (the default) | standard | about 25k tokens |
| "in depth", "thoroughly", "teach me" | deep | about 45k tokens |
Whichever row you land on, the levers are the same: searches and fetches capped by depth (table above), three to five bullet notes after each fetch instead of re-reads [Fetching], the page written in one file-creation call, and a plan of one line per item [Writing]. A finished run prints no token statistics — staying under the ceiling is the workflow's job, not the reader's [Context report].
Budgets are rules in the workflow, not intentions in a prompt.
The classifier is applied-in step two of every run; the template and policies are part-of the standard load; the twelve domains enable topic-specific guidance without being read whole; and scripts/validate.sh measures-by conformance against the OKF rules.
Not a static-site generator, a wiki, or a chat log: one question produces one page, with no JavaScript, no analytics, and no network calls when opened. It is also not a research engine — reference counts are hard caps, and citations come from sources actually retrieved in that run.