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.
ta-amps · Agora, the overview · October 30, 2026
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.
The problem
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.
The idea
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.
ILLUSTRATION · NOT A MEASURED RUN
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.
The idea · a worked example, illustrated
Speaker notes
This is an illustration of how the work is organized, not a measured run. 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 no tokens are spent.
- Illustration 0 tokens when the same pipeline is asked for again. An illustration of how the work is organized, not a measured run: when search and retrieval return a stored solution, no model is called and no work is repeated. The zero-token result that is measured is narrower: compiled code recipes run as plain code, on the evidence slide.
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. Live today for our own services; new repos, papers and releases are next.
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. So far the rows come from templates and the tests are synthetic; learning from real work reports is next.
measured on the learning slide
The idea · how it fixes each one
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. Today a daily check watches our own live services; feeds for new repos, papers and model releases come next. 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 synthetic; 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.
The idea · feeds
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. Today only our own live services are watched; feeds for new repos, papers and model releases come next, with the tool-discovery and freshness packs.
ILLUSTRATION · NOT A MEASURED RUN
Keeping your agent current: memory systems
Hundreds of new memory systems for agents appear on GitHub within days, far more than anyone can test alone.
SERVER WORKERS CLAIM VERBS
PLANNED
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
Kept up to date as new systems appear. Every rating is a noun, with its benchmark and source.
ANYONE’S AGENT, EVERY WEEK
“Has anything launched that fits my setup and is faster or cheaper?”
It pulls the shared comparison, so nobody tests the same system twice.
PLANNED, NOT RUNNING
The repo and paper feeds this needs don’t run yet. Today the only feed that runs is a daily check of our own live services.
705 / 739
DONE ONCE ALREADY · MEASURED
public repos in the hackathon’s directory, scanned into nouns and verbs without running their code
The idea · feeds, an illustrated example
Speaker notes
This is an illustration, and the feeds it needs are planned, not running. Hundreds of new memory systems for agents appear on GitHub within days, far more than any one person or team can test; that is this example’s premise, not a count we have recorded. Here, server workers claim verbs on a schedule: find the new systems through official APIs only, never by scraping, gather comparable benchmarks for each one, and store every system, result and source as nouns. Anyone’s agent can then pull a comparison that stays up to date across several dimensions, such as recall, speed, cost and fit with its own setup, and ask each week whether anything has launched that fits its setup and is faster or cheaper. Nobody tests the same system twice. The repo and paper feeds don’t run yet; today the only feed that runs is the daily check of our own live services. The precedent is real and measured: a deterministic scan read 705 of the 739 public repos in the hackathon’s directory into nouns and verbs, without running any of their code.
- Illustration Hundreds of new memory systems for agents on GitHub within days. The premise of this illustration, not a count we have recorded. No feed counts new memory systems yet.
- Planned Feeds for new repos and papers, run by server workers. Planned, not running. Tessera already serves the feed tools, and today the only feed that runs is the daily check of our own live services. Feeds for new repos, papers and model releases come next, starting from the tool-discovery and freshness-checks packs; the always-on server workers deck has the dated status. Evidence
- Measured 705 of 739 public repos in the event directory scanned into nouns and verbs. The real precedent for this illustration, and the same scan as the proof slide: 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.
- 59 packs live in one library, each named for what it does.
- 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.
How the pieces fit · seed packs
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 59 seed packs in one library, with 1,177 nouns, 381 verb templates and 37 worked examples. A count of the packs in the seed-pack library's README at commit d837b30, on October 30, 2026. 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: ta-amps.github.io, under the repository name
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
How the pieces fit · the map
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.
How the pieces fit · Tessera, infrastructure
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.
How the pieces fit · Herma, infrastructure
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 on a frozen, synthetic tool-call test of 150 rows
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 synthetic 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.
What works · learning, measured on synthetic tasks
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 on a frozen, synthetic tool-call test of 150 rows. 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 synthetic 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 frozen, synthetic tool-call test of 150 rows. Evidence
- Measured Llama 3.2 3B: exact match 52.0% to 72.7%. The same loop and the same frozen, synthetic test, 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 synthetic 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
Synthetic workloads, October 29, 2026. Methods, failures and limits are in Agora’s dated status report.
Speaker notes
All measured on synthetic 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 synthetic 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
What works · proof you can check yourself, published October 30, 2026
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 at github.com/ta-amps. Each name says what the repo is.
What works · the repos
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 synthetic, so results describe our test sets, not the world.
- Passing runs show that these agents and versions worked, not that every agent will.
- Hosted volunteer runs on Eranos are planned, and no nonprofit is claimed to use a kit yet.
- The exploitation-evidence pack’s evaluation has no score yet.
- The process for adding and rolling back shim rules isn’t finished.
- Feeds for new repos, papers and model releases come next; today the daily check watches our own services.
Every failure stays on the record, and unknowns stay unknown.
Honest limits
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.