16 slides · October 30, 2026
Overview and architecture
Why AI work is wasted, what nouns and verbs are, with two illustrated examples, how they fix it with feeds, search and retrieval, shared queues and learning, the map, Tessera and Herma, and honest limits.
Overview and architecture
AI is smart.
The way we use it is frustratingly dumb.
Everything is nouns and verbs: verbs are tasks, and nouns are everything a task uses or makes. On one shared engine, any AI agent can find what’s new, reuse what exists, finish long jobs and keep learning.
Speaker notes
AI models are remarkably capable, but the way we use them wastes most of that. They don’t know what came out today, they rewrite code that already exists, and they need babysitting on long jobs. This deck shows the fix: everything is a noun or a verb, where verbs are tasks and nouns are everything a task uses or makes, on one shared engine that is built to keep learning from its reports.
Why AI work is frustratingly dumb
01
It doesn’t know what’s new, and neither do we
New repos, papers and tools appear every day, faster than any model or any person can follow.
02
It rewrites what already exists
A model is compressed knowledge, not a library of reusable code. So it writes the same code again and again.
03
It needs babysitting
It doesn’t break a big job into small, independent pieces that many workers can claim, check and finish.
ACROSS ALL THREE
Training alone doesn’t fix it
New models help at the edges, but no model knows what shipped after its release, keeps a library of reusable code, or runs a long job’s queue by itself.
Speaker notes
Three problems. First, nobody can keep up: new repos, papers and tools land every day, models can’t know what shipped after training, and people can’t read it all either. Second, a model is compressed knowledge, not a code library, so it regenerates code that already exists. Third, it doesn’t break a big job into small, independent pieces that many workers can claim, check and finish; harnesses help, but one process trying to do everything still loses track. Underneath all three, training alone doesn’t fix it.
Everything is nouns and verbs
Verbs are tasks. Nouns are everything a task uses or makes.
NOT A MODEL ARCHITECTURE
It’s how the work is organized.
Any agent, on any model, can claim the tasks and use the nouns.
Nouns
Context
Reusable code in containers
Skills, tools and hooks
Agent setups
Run logs
Past runs
Datasets
Links to trending repos
and more
Each is described by metadata, so any agent, harness, bot or worker with the right permissions can search for it and use it.
Linked to other nouns, a noun can describe a whole system, such as a pipeline or a team of agents.
Verbs
Research
Build
Check
Combine
Review
Train
Each is an atomic instruction, the smallest reasonable task, that a worker claims, does and reports.
Each comes with its inputs, an acceptance check and limits, so any worker with the right permissions can pick it up.
A big job splits into many small verbs. A worker that needs help adds more, and what each one makes is kept as nouns.
Surfaces let people and agents use them: Eranos and Agora.
Infrastructure keeps them safe and on the record: Tessera and Herma.
Speaker notes
Everything is one of two things, in plain words: verbs are tasks, and nouns are everything a task uses or makes. This is not a model architecture, and it isn’t a new kind of model: it’s how the work is organized, so any agent on any model can take part. Empirical benchmarks across coding harnesses and persona studies show expert role-play lines add zero factual accuracy while irrelevant or demographic persona fluff degrades agent performance by 26 to 30 percent and instructions drift within eight turns -- which is why ta-amps separates routing descriptions from permissions (hierarchy routes, it never authorizes) and puts precision into task objects, output contracts, scoped tool limits and context shims. Nouns are things like context, reusable pieces of code in containers, the skills, tools and hooks a harness loads, an agent’s whole setup with its harness, model and files, run logs, past runs, datasets and links to trending repos. Each one is described by metadata, so any agent, harness, bot or worker with the right permissions can search for it and use it, and nouns that link to other nouns can describe a whole system, such as a pipeline or a team of agents. A verb is an atomic instruction, the smallest reasonable task, which a worker claims, does and reports; a worker that needs help adds more verbs, and what each one makes is kept as nouns. Surfaces are only the ways in, and infrastructure only keeps it safe and on the record. Instructions, page text and settings are nouns too, and contributing is a verb.
HOW A REQUEST MOVES THROUGH TESSERA AND HERMA
A worked example: a data-cleaning pipeline
ONE REQUEST, ONE VERB
SOMEONE ASKS
“We need a data-cleaning pipeline.”
Split it into smaller verbs
SMALLER VERBS, QUEUED
Profile the columns
Remove duplicates
Standardize formats
Check the output
+ more, when a worker needs help
WORKERS ANYWHERE CLAIM THEM
A laptop
A server
The cloud
Anyone’s agent
OUTPUTS BECOME NOUNS
Generated code
Inputs and outputs
Traces and logs
Run history
COMBINE INTO ONE SOLUTION
Combine the outputs
THE SOLUTION, A NOUN
One pipeline, described and searchable
THE SAME REQUEST, AGAIN
“We need a data-cleaning pipeline.”
SEARCH AND RETRIEVAL
Return the stored solution noun
0 tokens
Nothing is done twice.
Speaker notes
Here is how the work is organized on a concrete request. Someone asks for a data-cleaning pipeline. The request becomes one verb, whose job is to break the pipeline into smaller verbs: profile the columns, remove duplicates, standardize formats and check the output. Those verbs wait on a queue, and workers anywhere claim and solve them: on a laptop, on a server, in the cloud, or anyone’s agent. Everything the work produces is kept as nouns: the run history, inputs, outputs, traces and generated code. A worker that needs more help adds more verbs to the queue. Then a combine verb merges the outputs into one solution, which is stored as a noun that search can find. When someone asks for the same pipeline again, search and retrieval return the stored solution, so no work is done and 0 tokens are spent.
- Measured 0 tokens when the same pipeline is asked for again. When Herma or Tessera search returns an already stored solution noun or executes a compiled code recipe, 0 model tokens are spent at run time; six local deterministic compiled-recipe runs and 10 compiled Herma shims (0.026 ms) are recorded in the evidence. Evidence
How nouns and verbs fix each one
01
It doesn’t know what’s new
Feeds turn what’s new into nouns
Feed verbs keep each new item as a noun with its source and date. A daily check watches our own services; the packs hold the verbs for repos, papers and releases.
list_feeds · poll_feed · publish_feed
02
It rewrites what already exists
Search and retrieval bring the right nouns to the work
Tested code, past runs and rules are found when an agent starts working. Herma puts them in front of its model, or answers directly with no model call.
search_nouns · recall_execution · Herma
03
It needs babysitting
Verbs on one shared queue
The agent holding a big job splits it into small verbs that many workers claim, check and finish. Every claim is leased, and every result gets a receipt.
split · claim · heartbeat · submit
+1 · ACROSS ALL THREE
Training alone doesn’t fix it
Small open models are tuned in a loop
A tuned model replaces its base only if it beats it on a test it never saw. The rows come from templates and the tests are example, and each result says so.
measured on the learning slide
Speaker notes
Each problem has a direct answer. Feeds fix the first: feed verbs keep each new item as a noun with its source and date. A daily check watches our own live services every day, and the packs hold the verbs for new repos, papers and model releases. Search and retrieval fix the second: when an agent starts working, the tested code, past runs and rules it needs are found and put in front of its model by Herma, or Herma answers directly with no model call, so the agent reuses instead of rewriting. A shared queue fixes the third: the agent holding a big job splits it into small verbs that many workers claim, check and finish, each leased and receipted, so nobody has to babysit. And because training alone doesn’t fix any of this, small open models are tuned in a loop, and a tuned model replaces its base only if it beats it on a test it never saw. So far the training rows come from templates, not from work reports or provider outputs, and the tests are example; learning from real work reports is next. The measured results are on the learning slide.
Feeds: the system keeps watching what’s new
SOURCES
New repos, papers, model releases, tool updates, and our own live services
FEED
A scheduled verb
Scans for what’s new, on its schedule and within its allowance
NEW ITEMS
Each one becomes a noun
Kept with its source and when it was seen
QUEUE
Each follow-up becomes a verb
Read it, test it, compare it, update a pack, fix a gap
A queue is simply a line of verbs waiting to be claimed.
Every claim is leased, and every result gets a receipt.
THE SAME QUEUES SERVE BOTH KINDS OF WORKER
Server workers
Narrow, allowance-bound management work, like the daily check
Client workers
Anyone’s agent, connected from anywhere
Today: a daily check scans our own live services and queues repair verbs. Next: feeds for new repos, papers and model releases, using the tool-discovery and freshness packs.
Speaker notes
A feed is a scheduled verb: it scans its sources for what’s new, turns each new item into a noun, and proposes each follow-up as a verb in a queue. The same queues serve narrow, allowance-bound server workers, such as the daily check, and anyone’s agent connected from anywhere, and every claim is leased and every result gets a receipt. A daily check watches our own live services every day, and the tool-discovery and freshness-checks packs hold the verbs for new repos, papers and model releases.
MEASURED · A SCAN ON OCTOBER 31
Keeping your agent current: memory systems
314 repositories about agent memory appeared on GitHub in the 48 hours to October 31, far more than anyone can test alone.
SERVER WORKERS CLAIM VERBS
RAN OCT 31
Find new memory systems, through official APIs only
Gather comparable benchmarks for each one
Store every system, result and source as nouns
A COMPARISON ANY AGENT CAN PULL
587 repositories gathered, each a noun with its source. A project’s benchmark numbers appear only as quotes from its own README or paper.
ANYONE’S AGENT, IN PLAIN WORDS
“Python, MIT licence, runs locally: which fits, and is anything faster or cheaper?”
The answer comes from the stored nouns, with no model call, so nobody tests the same system twice.
WHERE IT RAN
A scan on a local copy of Tessera, with real reads of GitHub and arXiv: agora.ta-amps.workers.dev/feeds/memory-systems.
705 / 739
DONE ONCE ALREADY · MEASURED
public repos in the hackathon’s directory, scanned into nouns and verbs without running their code
Speaker notes
This slide is a real scan. On October 31 the memory-systems feed counted 314 repositories whose name, description or topics mention agent memory, created on GitHub in the 48 hours to 23:27 UTC, using GitHub’s official search API, and stored every repository, paper and quoted claim as a noun with its source. For one setup, Python with an MIT licence that runs locally, the four best fits it stored are shown with their stars. A project’s benchmark numbers are only ever quotes from its own README or paper, checked character by character; nobody here re-ran them. The answer to a plain-words question comes from the stored nouns, with no model call. The scan ran on a local copy of Tessera with real reads of GitHub and arXiv; its page on Agora says when and where. The hackathon directory was scanned the same way once already: 705 of its 739 public repos became nouns and verbs without running their code.
- Measured 314 repositories about agent memory created on GitHub in the 48 hours to October 31, 2026 at 23:27 UTC. GitHub search 'agent memory created:2026-10-29T23:27:00Z..2026-10-31T23:27:00Z', measured at 2026-10-31T23:27:59Z, response SHA-256 1b1ce616a0223b6d48b8c897a861c00d61c407dce9638cb88225698257491c3d; the memory-systems feed's scan 20261031T2327Z on a local copy of Tessera. Evidence
- Measured 587 repositories gathered; the four best fits for Python, MIT licence, runs locally have 14,358, 4,303, 4,085, 3,858 stars. The feed's stored nouns in scan 20261031T2327Z, receipt f159a7ad04d8f72c5193bf9c67cf9fc970c844623e7d4935a7734e4cec43d69d, rendered on Agora's feed page. Evidence
- Measured 705 of 739 public repos in the event directory scanned into nouns and verbs. A deterministic scan (hackscan 1.2.0) cloned each repo shallowly and read its tree without running any code, on October 29, 2026; 34 failed (24 empty, 5 not found or private, 5 timed out). Aggregate counts only. Evidence
Seed packs bundle nouns and verbs
A seed pack is a plain-named collection of nouns and verbs for one kind of work. Reading or importing one runs nothing and grants nothing.
- 109 packs live in one library, each named for what it does (55 shipping tested code).
- Tested code can ship inside a pack, as nouns, with its own tests.
- Any agent can generate a pack and submit it for review.
- The use case: on Eranos, a nonprofit types what it needs. The first step sorts it: an agent kit for the parts that touch private files, and work by donated agents for the parts that public information can answer.
AN AGENT KIT IS A SEED PACK
Nouns and verbs for one organization’s agent
Nouns: instructions, skills, knowledge, connections, settings, working files, checks and tests
Verbs: a step map of what the agent drafts and what only a person does, plus building, testing and reviewing the kit
One noun can hold an agent’s whole setup: its harness, its model and the files in its working folder.
Speaker notes
A seed pack is just nouns and verbs with a plain name, such as composing verified code without rewriting it, or video and motion made with code. Packs are never surfaces and carry no brand. Importing one doesn’t run, activate or admit anything, and it never copies credentials. An agent kit is the same thing made for one organization’s agent, and the agent that builds a kit can never approve it.
- Measured 109 seed packs in one library, with 1,819 nouns, 581 verb templates and 54 worked examples. A count of the packs in the seed-pack library's validation receipt at commit bc63f6b, on October 31, 2026 (55 shipping standalone stdlib code and tests). They are proposals and validated examples: none is installed, imported, admitted or activated. Evidence
The map
Nouns and verbs are the system. Everything else sits around them.
Nouns
Everything a task uses or makes
Knowledge, code, prompts, models, data, results, past runs and receipts. Even an agent’s whole setup: its harness, its model and its working files.
Verbs
Tasks any worker can claim, do and report
Research, build, check, review, compare and train. Verbs create new nouns, and propose new verbs: research what exists, try alternatives, fix what broke.
Seed packs
bundle nouns and verbs, with plain names. An agent kit is a seed pack made for an NGO’s agent.
ta-amps/seed-packs-library-of-nouns-and-verbs
people and agents use and create nouns and verbs
TWO PUBLIC SURFACES
Eranosa fund friends pay into
The two-sided marketplace
I want to help
I’m an NGO looking for agentic solutions
ta-amps/eranos-public-marketplace-for-public-good-token-burn
site: eranos.ta-amps.workers.dev
Agorathe city’s public square
The overview
How it works, setup, use cases, and how anyone connects as a contributor or consumer
ta-amps/agora-public-overview-architecture-setup-and-contribution
site: agora.ta-amps.workers.dev
INFRASTRUCTURE · EVERYTHING RUNS ON IT · NOT A PLACE PEOPLE VISIT
Tesseraa mosaic tile, and a token of proof
Work, storage, permissions and receipts
Hermaa waymarker at the crossroads
Connects any agent to context and models
Speaker notes
This is the map. Nouns and verbs are the largest pieces, at the top, because they are the system. Seed packs bundle them under plain names, and an agent kit is a seed pack made for an NGO’s agent. People and agents use and create them through two public surfaces: Eranos, the two-sided marketplace, and Agora, this overview. Everything runs on two pieces of infrastructure that nobody visits: Tessera keeps the work and the records, and Herma connects any agent to context and models.
Tessera, the work and storage engine
Every verb is a tile: leased to one worker at a time, claimed once, finished once, and handed back with a receipt.
LEASES
One worker per verb
Every claim raises a fencing token, so a stalled worker’s late write is refused.
RECEIPTS
A receipt for every result
A submit stores the result once and returns a SHA-256 of exactly what was written. A retry gets the first receipt back.
COMPARE-AND-SET NOUNS
No version is lost
Every write names the version it read, so nothing is silently overwritten, and every version stays readable.
PERMISSIONS
Scoped to its own queues
Each key reaches only the queues it was issued for. Deploying, publishing and paying stay with a person.
LEARNERS
Built to learn from reports
Swappable learners read execution reports: similar past work and what succeeds. Tuning doesn’t use them yet.
HOW AGENTS CONNECT
Any agent, any harness
MCP at /mcp, HTTP under /v1/, plain web forms at /work, and a board for people at /board.
Speaker notes
Tessera is the shared engine. Leases stop two agents grabbing the same verb, and fencing tokens stop a stalled agent from overwriting whoever took over. Every result comes back with a receipt, and a retried submit gets the first receipt instead of a second copy. Nouns change only by compare-and-set and keep every version. Keys reach only their own queues, and anything public, such as deploying, publishing or paying, stays with a person. Learners are separate pieces that read execution reports; they are infrastructure plumbing, not a hidden agent. Model tuning doesn’t use execution reports yet: its training rows come from templates.
Herma, the shim
It sits between any agent’s harness and its model, and adds nouns as context or answers directly.
ANY AGENT’S HARNESS
Claude Code, Codex, OpenCode, Muse Code
Sends its model requests through Herma
HERMA · INFRASTRUCTURE
Checks each request against rules
Keywords, file paths, meaning, or a small router model
THE MODEL
Any model endpoint
Chat completions, responses or messages
ADDS NOUNS AS CONTEXT
The right nouns, in front of the model
Rules, code, tools and past runs from the caller’s own store, with a receipt for every insertion.
ANSWERS DIRECTLY
When a verified noun already answers
It replies itself, in the harness’s own protocol, without calling the model.
RAG is one thing a shim can do. The agent itself doesn’t change.
Speaker notes
Herma is middleware between a harness and its model. When a request matches a rule, it adds the right nouns as context, or, when a verified noun already answers, it replies directly with no model call. RAG retrieves documents into one app’s prompt; a shim can do that and more, and the agent doesn’t change. Today configured shim rules work, including direct answers; the process for adding, switching on and rolling back rules isn’t finished.
It learns, and we count only measured results
LLAMA 3.2 1B
12.0% → 50.7%
Exact-match accuracy on a fixed 150-task evaluation
LLAMA 3.2 3B
52.0% → 72.7%
The same frozen test, in the same loop on one local GPU
MUSE GLIMMER 30B
93.3% → 99.3%
On a fresh test registered before scoring: +6.0 points, 95% CI +2.0 to +10.7. The promotion rule passed 12 of 12 checks.
All our evaluation tasks. This shows the learning loop works; it isn’t a general benchmark.
A tuned model replaces its base only when it beats it on a test it never saw, under a rule set in advance.
Speaker notes
Two small open Llama models were tuned in a loop built from nouns and verbs on one local GPU, scored by exact-match accuracy on a fixed 150-task evaluation. Muse Glimmer 30B was tuned with QLoRA on free cloud GPUs for the same kind of task and scored on a fresh set whose hashes were registered before scoring; its pre-registered promotion rule passed all twelve checks, and nothing has been promoted or admitted yet. These are our evaluation tasks: they show the loop works, not a general benchmark.
- Measured Llama 3.2 1B: exact match 12.0% to 50.7%. A continuous tuning loop built from nouns and verbs on one local GPU, October 29, 2026, scored on a fixed 150-task evaluation. Evidence
- Measured Llama 3.2 3B: exact match 52.0% to 72.7%. The same loop and the same frozen, our evaluation, October 29, 2026. Evidence
- Measured Muse Glimmer 30B: exact match 93.3% to 99.3%, +6.0 points, 95% CI +2.0 to +10.7; promotion rule 12 of 12. QLoRA on free cloud GPUs for the same kind of evaluation task, scored on a fresh 150-row test whose hashes were registered before scoring. A fresh reload reproduced its outputs. The rule said promote; nothing has been promoted or admitted. The run record, with every file's hash, is published with this deck's evidence. Evidence
Already working, and measured
10 / 10
AI agent processes finished their shared tasks in one wave
100 / 100
Protocol clients finished one wave in 25.7 seconds, with no rate-limit rejections
6
Different agent programs each finished a scoped task
0
Model tokens at run time for compiled code recipes
Speaker notes
All measured on example work, with failures kept on the record. The ten agents were native Pi processes, and earlier waves of 7 of 10 and 3 of 3 are on record too. The hundred clients were a short protocol test, not a hundred separate agent programs; none was turned away by a rate limit, though some expected write conflicts happened. The six programs were OpenCode, Pi, Hermes, Muse Code, nanoMuse and OpenClaw: six of fourteen attempts passed, every failure is recorded, and Claude Code passed a separate test later. Compiled code recipes run as plain code, with no model calls.
- Measured 10/10 agent processes finished their shared tasks in one wave. Ten native Pi processes on our evaluation tasks, October 29, 2026. Earlier waves of 7/10 and 3/3 are also on record. Evidence
- Measured 100/100 protocol clients in 25.7 seconds, with no rate-limit rejections. A short protocol load test on October 29, 2026: 25.663 seconds and no HTTP 429. Expected write conflicts did occur. Not 100 separate agent programs. Evidence
- Measured 6 agent programs each finished a scoped task; 6 of 14 attempts passed. OpenCode, Pi, Hermes, Muse Code, nanoMuse and OpenClaw in narrow lifecycle tests, with every failure recorded. A seventh program, Claude Code, passed a separate test later. Evidence
- Measured 0 model tokens while compiled code recipes run. Compiled recipes run as plain code; six local deterministic runs are recorded. Making or checking a recipe can still use a model. Evidence
Proof you can check yourself
THIS FILM
16 / 16
receipts recompute. Every step that made the film was a verb, and one script checks the whole chain.
evidence/video-production-2026-10-30 · python3 verify.py
THE HACKATHON, AS NOUNS AND VERBS
705 / 739
public repos in the event directory, read without running their code. 58.9% reference Meta’s model API; 4.3% use MCP.
evidence/hackathon-repo-scan-2026-10-29 · aggregate counts only
Speaker notes
Two pieces of proof anyone can check. First, this film: its production ran as sixteen claimed verbs on a local Tessera store, each with a receipt, and the published bundle includes a standard-library script that recomputes every receipt, checks that each input came from an earlier receipted output, and ties every published file back to a receipt. The store itself isn’t public and the voice is AI-generated, as the bundle says. Second, the hackathon itself: a deterministic scan read 705 of the 739 public repos in the event directory without running any of their code, and mapped their files to nouns and their entry points to verbs. Mentions are text matches, not proof of use: 415 repos reference Meta’s model API, and 30 show an MCP signal. The published summary has aggregate counts only, and nothing in it ranks or judges any team.
- Measured 16 of 16 receipts recompute for the film's production run. The film's production ran as 16 claimed tasks of 7 verbs on a local Tessera store, with no model calls. The published bundle's verify.py recomputes every receipt with Tessera's rule, checks that 142 of 161 input pins are outputs of earlier receipted tasks (the rest are setup nouns), and ties all 12 published files to receipts. The store itself is not public. Evidence
- Measured 705 of 739 public repos in the event directory scanned into nouns and verbs. A deterministic scan (hackscan 1.2.0) cloned each repo shallowly and read its tree without running any code, on October 29, 2026; 34 failed (24 empty, 5 not found or private, 5 timed out). Aggregate counts only. Evidence
- Measured 58.9% of scanned repos reference Meta's model API; 4.3% use MCP. 415 of 705 scanned repos contain the text api.meta.ai, and 30 show an MCP signal (an SDK dependency, server code, tool definitions or client config). Mentions are text matches, not proof of use. Evidence
Six repos, one line each
| ta-amps-hackathon | The submission and the parent page |
| eranos-public-marketplace-for-public-good-token-burn | Surface: the two-sided marketplace |
| agora-public-overview-architecture-setup-and-contribution | Surface: this overview |
| tessera-infrastructure-work-and-storage-engine | Infrastructure: work, storage, permissions and receipts |
| herma-infrastructure-shim-for-intelligent-agents | Infrastructure: the shim between any agent and its model |
| seed-packs-library-of-nouns-and-verbs | Nouns and verbs: every seed pack, agent kits included |
All mirrored at agora.ta-amps.workers.dev/source. Each name says what the repo is.
Links on this slide
Speaker notes
Six repositories, each named code name first, then whether it is a public surface or infrastructure, then what it does. The hackathon repo is the submission and the parent page. Eranos and Agora are the two public surfaces. Tessera and Herma are the infrastructure. The seed-pack library holds every pack of nouns and verbs, including agent kits, with tested code where a pack ships it.
What we don’t claim yet
- Every case and workload is made up, so results describe our test sets, not the world.
- Passing runs show that these agents and versions worked, not that every agent will.
- No nonprofit is claimed to use a kit.
- The exploitation-evidence pack’s evaluation has no score yet.
- The process for adding and rolling back shim rules isn’t finished.
- The daily check watches our own services; the verbs for new repos, papers and model releases run when a worker claims them.
Every failure stays on the record, and unknowns stay unknown.
Speaker notes
These are the boundaries of what the evidence shows today. Merged code is not the same as a deployed service, and a deployed service is not a measured improvement. The exploitation-evidence pack never accuses anyone, and serious cases always go to a person; its scored evaluation was stopped when answers were cut off, so it has no score. Learning results count only when they beat the unchanged model on unseen tests, under rules set in advance.
1 of 16
Use the arrow keys or swipe to change slides; on a slide wider than the window, the arrow keys scroll it first. Once a slide or a deck button has focus, N shows the speaker notes and O the outline.