Chris Robertson / AI capabilities
32 AI techniques, each mapped to the page where it runs, the code that does it, and how it is checked. Pages marked public work without signing in; the rest are part of the private workspace and can be shown in a demo.
Every page has its own agent, wired to Model Context Protocol servers for data, page actions, retrieval, protein folding, CAD, Wolfram and more. Each server is a small stdio process with a typed tool list.
The /harness replay shows each tool call and result from a real session log.
A board of role-played executives answers in turn and a chair closes with a decision, the strongest dissent, one next action and what would reverse it.
Decisions persist and resurface on the next board's agenda until resolved.
One question goes to several models at once; a synthesis step merges them and scores how much they agree, so disagreement is visible rather than averaged away.
Returns per-model latency and a 0–100 agreement score with the merged answer.
Builds a brief on a person from public sources only; every claim carries its URL and an unsourced claim is dropped rather than shown.
Fields with no source render as not found.
An admin-tier agent with shell and file tools, scored on fixing real tasks in a throwaway copy of the repository.
Each case runs in an isolated worktree and is scored on its result, not its transcript.
A cloud browser sandbox drives the open web for tasks no API covers; local Playwright drives this app's own pages for end-to-end checks.
Recorded browser sessions replay with console logs on Developer Sessions.
Dense embeddings and BM25 run side by side and are fused by reciprocal rank; short queries are expanded from the corpus's own headings. Every answer cites a document and heading, and the search reports whether it found evidence at all.
Falls back to lexical-only and says so when no embedding cache is present.
Each page agent gets a compiled context: its charter, its skill notes, a snapshot of what is on screen, and a token budget set per surface.
`python -m harness.evals.page_agent --policy` prints the lane and budget per page.
Signed-in agents keep page memory across sessions; repeated human feedback is distilled into explicit learnings an agent reads before it answers.
Learnings carry the evidence count and agreement behind each rule.
CSV, Excel, Word and PDF files are read into a structured form agents can query, on the web process or a worker.
Covered by the document service tests.
Recorded sessions are re-scored for free before and after a change; live cases run against the real permission tier, so an agent that reaches outside its scope fails.
`python -m harness.evals.page_agent --replay` costs nothing to run.
A judge model scores paired answers; its scores sit beside human votes so judge–human agreement can be measured rather than assumed.
A pair with no judge score shows blank, never zero.
Fixtures plant instructions inside data an agent reads; the trajectory scorer fails any run that acts on them or touches a table outside its grant.
Runs as part of the page-agent eval suite.
Anonymous, signed-in and admin audiences get different tools and tables, enforced by the server; sensitive tables never reach an anonymous visitor.
`tests/test_public_scope.py` fails if a sensitive table leaks to the public tier.
Every page grades itself on eight parts, and a second column is read from the code, so a page cannot claim a feedback loop it does not wire.
`python3 scripts/audit/page_inventory.py --matrix` prints claimed vs verified.
A classifier trained on the LLM triage engine's verdicts suggests goal, task or note for each captured input — in the web process, for free.
Cross-validated against a majority-class baseline; metrics are on the model card.
Temperature scaling makes the student's confidence mean what it says; below a threshold chosen for 90% agreement, the input is left for the LLM.
Expected calibration error before and after scaling is on the card.
Correcting a suggestion on the Tasks page writes a label to the shared label spine; the next training run prefers it over the teacher's verdict.
The model card counts human and teacher labels separately.
Pairwise votes, rubric scores, critique tags and gold rewrites, exported as DPO, KTO or SFT JSONL with an Elo leaderboard over models.
A tie or a both-bad vote exports no DPO pair, because no winner was named.
Fold a sequence with ESMFold or fetch an AlphaFold prediction, then read its per-residue confidence in a 3D viewer.
The agent reports mean pLDDT from the fold it ran, never an invented score.
Future-state renders of real rooms use a precise-edit model chosen by measurement: untouched regions stay within 1.6/255 across two different designs.
Pixel-level comparison on the repository's own photos in IDEOGRAM_RENDERS.md.
Photos and walkthrough videos become drafts of rooms, assets, inventory and garments that wait for approval before they become records.
Nothing extracted is written to a record table until a person approves it.
Agents watch an attached clip or a render natively, not frame by frame.
Exposed to agents as mcp__page__analyze_video.
Speech-to-speech conversations over WebRTC, with a choice of engine, persona and page tools.
The same page tools the text agents use are available by voice.
Voice notes are transcribed and turned into a titled, categorised memo plus the goals they mention; Command Center counts those goals.
Writes voice_memos and user_goals rows, each tied to its source recording.
Type a line and hear it in a cloned voice, then render a lip-synced video, running locally rather than through a hosted API.
Reports model readiness before a render is attempted.
Songs move from staged to released under artist brands; lyrics become shot-by-shot prompts for video models, and results land in one review queue.
Every generated asset passes through the Queue Dashboard before it is posted.
Every task has four tiers, from flagship down to a free local model, with the price of one run and the fallback a failing call walks.
Shows the declared ladder beside what the spend ledger actually recorded.
Page agents reuse a cached prefix (charter, skills, tool list), so most input tokens are billed at the cache rate; cached tokens are recorded on every call.
llm_spend.cache_read_tokens per call; the cost meter shows the hit rate.
Every model call is metered against the page and task that made it, and long-running work is traced end to end.
Spend by model, by page and per call over 7, 30 or 90 days.
Each table is mapped to the pages that write and read it; every agent's data tool reports how old the newest row is, and agents say so when data is stale.
`python3 scripts/audit/data_flow.py --live` runs in a read-only transaction.
Requests become jobs on a shared queue; the page polls for the result, and a rejection with a reason is recorded as feedback.
Each fire records its job number, status, cost and result.
See where each modern AI technique runs in this system — agents, retrieval, evaluation, training, vision and voice, production operations — with the page to try it, the code behind it and how it is checked.