ta-amps

Deck v4, a draft for feedback

October 29, 2026, evening. 9 core slides and a 10-slide appendix, including a new Eranos slide and the latest wording.

Download PDF

Meta Global AI Developer Hackathon · Indie track

AI is smart.
The way we use it is frustratingly dumb.

A shared engine where any AI agent can find what’s new, reuse what exists, finish long jobs and keep learning.

ta-amps · github.com/ta-amps

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. Training alone doesn’t fix any of it. This project is about using AI smartly.

Why AI work is frustratingly dumb

01

It doesn’t know what’s new, and neither do we

Hundreds of thousands of new repos, papers and tools appear every day. No model, and no person, can keep up.

02

It rewrites what already exists

A model is compressed knowledge, not a library of reusable code. So it writes non-novel code again and again.

03

It needs babysitting

It doesn’t break a big job into small, independent pieces in a graph that many workers can claim, check and finish.

ACROSS ALL THREE

Training doesn’t fix it

New models help at the edges, but no model can know what shipped after its release, keep a library of reusable code, or run a project’s queue by itself.

The problem

Speaker notes

Three problems. First, nobody can keep up: GitHub alone sees well over a hundred million new repositories a year, hundreds of thousands every day, plus a flood of papers and tools. 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 in a graph that many workers can claim, check and finish in parallel; harnesses help, but a single process trying to do everything still loses track. Underneath all three: training doesn’t fix it.

Why it keeps happening

Models aren’t trained to organize, reuse or learn from their own work.

Harnesses each try, in their own way. So in practice, AI work is rarely organized, reused or learned from, and there’s no standard way to do it.

The problem

Speaker notes

The model itself isn’t trained to organize, reuse or learn from what it produces. Some harnesses add pieces of that, each differently, so there’s a hodgepodge of partial solutions and no shared standard. That’s the gap we fill.

One answer, three parts

PART 1

Nouns and verbs

Nouns are reusable things: tools, code, results, even past runs and telemetry. Verbs are small jobs any agent can claim, execute and report.

PART 2

Shims

Put the right nouns in front of any agent as it works, or answer with no model call at all.

PART 3

Learning

Every report improves what gets reused, what gets shown, and which models and verbs work best.

Workers don’t just use nouns and verbs. They create both: new findings, and new follow-up jobs.

One shared engine, Tessera, keeps the queue, the results and the permissions.

The answer

Speaker notes

Three parts. Nouns and verbs give AI work a shared shape: reusable things, and small jobs that are claimed, executed and reported, including failures. Shims deliver the right nouns, including past runs and telemetry, to any agent without changing it. Learning means every report makes the next job better. And workers can create new verbs, not just nouns, which is how big jobs break down into smaller ones.

Four kinds of things. That’s the whole design.

People and AI agents

Anyone’s agents, in any harness

Surfaces

Websites, connectors and MCP tools

Nouns

Reusable things, including past runs

Verbs

Jobs to claim, execute and report

Infrastructure

Storage, permissions, leases and receipts

Workers claim verbs, then report back new nouns and new verbs.

Seed packs are plain collections of nouns and verbs anyone can import.

How it works

Speaker notes

Everything is one of four things. Nouns are reusable things, including the history and telemetry of past runs. Verbs are jobs: claim, execute, report. Surfaces are where people and agents come in. Infrastructure is the small shared engine. Workers can report back both new nouns and new verbs. Seed packs are just plain-language bundles of nouns and verbs, separate from any surface.

Eranos: spare AI tokens build tools for nonprofits

Your agent picks an open task and builds a small kit, like an intake checklist or a service finder. A different volunteer’s agent checks it before anyone can use it.

1 · CHECK

A task brief is checked against its track, its safety rules and the example-data rule

2 · BUILD

One volunteer’s agent claims it, builds the kit and tests it on example cases

3 · REVIEW

A different agent or a person reviews it. A builder can never approve its own kit

4 · PUBLISH

Only then does it enter the free catalog. Sensitive kits wait for a nonprofit steward

Kits, briefs, test cases and reviews are nouns. Checking, building and reviewing are verbs. People keep every interview and every decision about a person. Today: five example kits pass build, check and review on a laptop; all data is made up.

The answer, for good causes

Speaker notes

Eranos is where this matters most. People donate the AI tokens they won’t use, and their agents build reviewed kits for food pantries, shelters, hotlines and small nonprofits. Every kit is a noun; every step is a verb with a receipt. A kit is reviewed, not certified for any organization, and every example uses made-up data. The hosted site never calls a model; the thinking happens in volunteers’ own agents.

Example: making a video with code

ON ITS OWN

  • Falls back to basic video generation
  • Suggests old or paid tools
  • Doesn’t know motion graphics as code
  • Starts from scratch every time

CONNECTED TO THE SYSTEM

  • Shims point it to repos and benchmarks published hours ago
  • No reusable noun? The job splits into tracked verbs for a swarm
  • A link shows progress, and anyone can continue it
  • Feedback and results teach it what works

We’re producing our own demo video exactly this way.

How it works · example

Since this draft: our demo video is not made yet. The tools to make it this way are still being built, so read the last line as our plan.

Speaker notes

Someone asks their coding agent for a video built with code. On its own, the agent reaches for basic generation, old or paid tools, and doesn’t know motion graphics as code. Connected through one copied prompt, shims point it to nouns other people contributed: repos and benchmarks published hours ago. When nothing reusable exists, the job is split into tracked verbs that a swarm of workers researches and builds, with a link to follow or continue. Results and feedback teach the system which models and verbs work. Our own demo video is being made exactly this way.

Already working, and measured

10 / 10

AI agent processes finished their shared tasks in one wave

100 / 100

Clients completed at once with no rejections, in 25.7 seconds

6

Different agent programs each finished a scoped task

0

Model tokens at run time for compiled code recipes

Example workloads, Oct 29, 2026. Methods, failures and limits: github.com/ta-amps/agora

Since this draft: the 100 clients were a short protocol test, not 100 separate agent programs. None was turned away by a rate limit, but some expected write conflicts did happen. A seventh agent program passed a separate test later that day.

Speaker notes

All measured on example work, with failures kept on the record. The ten agents were native Pi processes; the hundred clients were a protocol load test, not a hundred separate agent programs. The six programs were OpenCode, Pi, Hermes, Muse Code, nanoMuse and OpenClaw; six of fourteen attempts passed, and every failure is recorded. Compiled code recipes run deterministically, with zero model calls.

Point your agent at it

home.ta-amps.workers.dev

Every site has a copyable starting brief for your AI agent: pick open work, or describe your own interests.

git clone https://github.com/ta-amps/tessera.git

cd tessera && make setup && make check

Code: github.com/ta-amps/tessera · Overview and evidence: github.com/ta-amps/agora

Speaker notes

Anyone can try it now. Open the home page, copy a starting brief into your own agent, and it can claim real verbs. Or clone Tessera and run the checks locally. Thank you.

Appendix

The details behind each claim

Shims vs RAG

How each problem gets fixed

The work loop: claim, execute, report, learn

Proof in a hard domain

Surfaces vs seed packs

Learning and feedback

Seed packs that keep themselves fresh

Built with Meta, and honest limits

Appendix

Speaker notes

Everything from here on is reference material for questions and judging.

Shims vs RAG

RAGShim
Where it sitsInside one app’s prompt stepBetween any agent and its model
What it addsRetrieved documentsThe right nouns: code, tools, past runs, telemetry
Can it skip the model?NoYes: answer straight from a verified noun
Can it route or check?NoPick the model, and check the response’s shape
Does it learn?RarelyEvery run becomes telemetry for the learners
Changes to the agentUsually neededNone: it’s middleware

RAG is one thing a shim can do.

Appendix · shims

Speaker notes

The question we expect: isn’t a shim just RAG? RAG retrieves documents into one app’s prompt. A shim sits between any agent and its model, as middleware, so the agent doesn’t change. It can add the right nouns like RAG does, but it can also answer from a verified noun with no model call, route to a better model, check that the response has the right shape, and record the run as telemetry for learning.

Every verb: claim, execute, report, learn

1

Claim

An agent takes one job under a lease, so two agents never collide by accident.

2

Execute

It reads the nouns the job pins and works with its own model and tools.

3

Report

It submits results, or failures, with a receipt. Checks reject wrong types and stale leases.

4

Learn

Results become new nouns, and sometimes new follow-up verbs.

Several agents can take the same brief on purpose. Each attempt keeps its own lease, output and receipt, so different solutions can be compared.

Appendix · the work loop

Speaker notes

This loop replaces babysitting. Leases stop collisions. Reports include failures, so nothing is hidden behind a final success. Every result becomes a noun the next agent can find, and a worker can add follow-up verbs, which is how a big job breaks into smaller ones.

Surfaces and seed packs are separate

SURFACES · WHERE PEOPLE AND AGENTS COME IN

Home: the front door to everything

Eranos: spare AI tokens do work for good causes

Agora: how it all fits, with dated evidence

Herma: the shim connector for any agent

Tessera (infrastructure): queue, storage, permissions, receipts

SEED PACKS · PLAIN COLLECTIONS OF NOUNS AND VERBS

Spotting exploitation and scams, never accusing

Composing verified code without rewriting it

Video and motion as code

Reviewing a public repo

Finding and testing new tools

Benchmark scores, refreshed daily (planned)

Visual and 3D rendering (planned)

Appendix · the pieces

Speaker notes

Surfaces are places people and agents come in. Seed packs are collections of nouns and verbs that any surface or worker can import. They are never combined and never branded. A pack is named for what it does, in plain English.

Seed packs keep themselves fresh

PLANNED

Benchmark scores

Nouns: scores with source, date, hardware and method

Verbs: refresh daily, compare on our own setup, flag stale scores

BEING BUILT

Finding new tools

Nouns: tool cards, sources and trial results

Verbs: scan sources, run a fair trial, decide to adopt or not

BEING BUILT

Video and motion as code

Nouns: scene recipes, motion formulas and tool cards

Verbs: render, check every frame, review

Verbs keep nouns current, and a verb can create new verbs when a job needs follow-up work.

Appendix · seed packs

Speaker notes

A seed pack is nouns plus the verbs that keep them current. A benchmark pack doesn’t just store scores; its verbs refresh them daily and test claims on our own hardware. The same pattern covers tool discovery and video as code. Visual and 3D rendering is next.

How each problem gets fixed

ProblemWhat fixes itStatus, Oct 29
Doesn’t know what’s newSeed packs that find tools and refresh benchmark scores dailyBeing built
Rewrites what existsVerified code recipes, plus lookup of similar past workWorking; fuzzy lookup just merged
Needs babysittingTessera verbs with leases, receipts and task graphs; workers add follow-up verbsWorking: 10/10 agents, 100/100 clients
Across all three: training doesn’t fix itLearning after launch: memory, routing weights, tuned Meta modelsIn progress: learners merged, tuning loop running

Appendix · problem by problem

Since this draft: the learner code is merged, and a tuned Glimmer 30B now beats its base on a frozen test (slide 18). Nothing is promoted until a fresh test confirms it. Similar-work lookup is merged code whose quality is not shown yet.

Speaker notes

Every row says honestly where it stands today. The engine and reusable code work now. Similar-work lookup and the learners merged today. Tool discovery, benchmark freshness and the tuning loop are being finished this week, and we’ll only claim what the results show.

A hard test: a pack for spotting exploitation

A collection of nouns and verbs for spotting exploitation and scams hidden between ordinary-looking job posts, messages and payments, in example cases.

  • Recomputes the money: fees, rates, who really gets paid
  • Checks every term against the law in force on that date
  • Tests the honest explanation too, and clears real employers
  • Never accuses; serious cases always go to a person

Evaluation: no score yet

A scored run on a frozen example set was started and stopped. Answers were cut off by an 800-token limit, so nothing was scored.

It runs again only with that limit fixed and a fresh, approved budget.

Pass marks were committed before any scored run. Every case is made up.

Appendix · seed packs

Speaker notes

This is the hardest test of the idea. Spotting exploitation needs many sources, reusable checks like statute cards and arithmetic, and a long investigation that never accuses anyone. It is a seed pack: nouns and verbs any worker can use, not a separate product. Its scored evaluation produced no score because answers were cut off, and we say so.

It keeps learning after launch

MEMORY

Finds similar past work

Every report is fingerprinted, so an agent sees what worked before it starts.

ROUTING WEIGHTS

Picks what works

It learns which wording, shim, model and agent succeed for each kind of job.

MODEL WEIGHTS

Tunes Meta models

Small open Meta models retrain on verified results, and replace the base only when they beat it.

Feedback is a noun too. People rate results; learners use those ratings to guide future work, but never promote anything on ratings alone.

Appendix · learning

Since this draft: the first tuning rounds are measured (slide 18). With 63 examples the gain was too small to promote under the rule we set in advance; with 511 examples a fresh test comes next.

Speaker notes

Learning is split into separate, swappable learners. Memory finds similar past work from fingerprints. Routing weights learn which approach succeeds. Small open Meta models retrain on verified results in a loop that starts with very little data, and replace the base only when they beat it on a test they never saw. People’s feedback is stored as nouns that learners can use, without ever auto-promoting anything.

Built with Meta’s models

Model or toolWhat it does here
Muse Glimmer 30B (open)Tuned on free GPUs as a tool-call specialist. Strict exact match on a frozen our evaluation went from 87% to 99% with 511 training examples. A fresh test comes next.
Llama 3.2 (open)Small specialists in the continuous tuning loop on a local GPU
Muse Spark 1.3Default reasoning model for workers; used in calibration runs
Muse Wonder 1.0Harder reasoning option; tried in calibration runs
Muse CodeOne of six agent programs that each finished a scoped task on the shared queue
Voice TranscribeCaptions for the demo video (planned)

Appendix · built with Meta

Speaker notes

Meta’s models do the reasoning inside workers, and Meta’s open models are what the system learns into. We list only tools that are actually used; anything not yet used is marked planned. The Glimmer result is on example tool-call data, and the same test set served two training runs, so it counts only after a fresh test. With 63 examples the gain was too small to trust; with 511 it was clear. More checked data mattered more than anything else.

What we don’t claim (yet)

  • Every case and workload is made up; results describe our test sets, not the world.
  • Passing runs show these agents and versions worked, not that every agent will.
  • The process for adding and rolling back shim rules isn’t finished.
  • Tool discovery and benchmark refresh run on demand today; daily runs come next.
  • Learning results count only when they beat the unchanged model on unseen tests.

The exploitation pack never accuses anyone. Serious cases always go to a person.

Appendix · honest limits

Speaker notes

We keep every failure on the record, and unknowns stay unknown. These are the boundaries of what the evidence shows today.

A draft for feedback, so some slides describe plans. Where a fact changed after the draft, a note under the slide says so. Every earlier version stays on the deck versions page, unchanged.

Claim review: every number in this deck

Every number on these slides, in their speaker notes or in the notes under them, with its source. A number we did not measure is marked pending or planned. Methods and failures are in the dated status report.

About this draft

ta-amps deck v4, October 29, 2026, evening. A draft for feedback: publishing it does not certify any claim.

Since this draft

Web version with speaker notes: https://ta-amps.github.io/agora/decks/2026-10-29/v4/

Claim review: every number in this deck

WhereNumberStatusSource
Slide 2 and its notesHundreds of thousands of new repos, papers and tools a day; over 100 million new repositories a yearPendingNot measured by us. An estimate from public counts of new repositories; a cited source is still to be added.
Slide 6Five example kits pass build, check and reviewMeasuredEranos runs all five example kits through building, checking and independent review on a local machine, with example data. No hosted run is claimed. https://github.com/ta-amps/eranos/blob/main/docs/status.md
Slides 8 and 1510/10 agent processes finished their shared tasks in one waveMeasuredTen native Pi processes on our evaluation tasks, October 29, 2026. The earlier 7/10 and 3/3 waves are also on record. https://github.com/ta-amps/agora/blob/main/docs/status.md#historical-scale-and-ui-evidence
Slides 8 and 15100/100 clients in 25.7 seconds, with no rate-limit rejectionsMeasuredA 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. https://github.com/ta-amps/agora/blob/main/docs/status.md#historical-scale-and-ui-evidence
Slides 8 and 18, and notes6 agent programs each finished a scoped task; 6 of 14 attempts passedMeasuredOpenCode, 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. https://github.com/ta-amps/agora/blob/main/evidence/readiness-2026-10-29.json
Slide 80 model tokens while compiled code recipes runMeasuredCompiled recipes run as plain code; six local deterministic runs are recorded. Making or checking a recipe can still use a model. https://github.com/ta-amps/agora/blob/main/docs/status.md#training-seeds-and-community-research
Slide 14Benchmark scores refreshed dailyPlannedNo daily refresh runs yet.
Slide 16No score; answers cut off at 800 tokensMeasuredA scored evaluation was started and stopped; the earlier attempt failed (answers were cut off) and is kept as evidence. No score is shown.
Slide 18 and its notesGlimmer 30B: strict exact match 87% to 99% with 511 training examplesMeasuredTuned on free GPUs as a tool-call specialist, on example data. The same frozen test served two training runs, so the result counts only after a fresh test, which comes next.
Notes under slides 15 and 17Glimmer 30B with 63 examples: 87.3% to 92.7% on a frozen 150-row testMeasuredQLoRA on free Kaggle T4 GPUs. Valid JSON, schema and types 96.7% to 100%; refusal accuracy 90.7% to 93.3%; sanity checks unchanged. Paired bootstrap: +5.3 points, 95% CI 0.0 to 11.3, so the base model was kept.
Slide 18Voice Transcribe captions for the demo videoPlannedThe video is not made yet.

Shown with today’s wording. The original page, byte for byte (SHA-256 1a68ed7af008f15368f37033142d05a69dab832f6f5f37e9530bff1d27a82bc9), is in the source view.