From b237820dfb01b1359c3b822fba0a5794519634fc Mon Sep 17 00:00:00 2001 From: edenbd1 Date: Wed, 19 Aug 2026 02:45:37 +0200 Subject: [PATCH] =?UTF-8?q?Solution:=20LP-0008=20=E2=80=94=20Autonomous=20?= =?UTF-8?q?AI=20Module=20with=20Wallet,=20Storage,=20and=20Messaging?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit An agent that participates in the Logos stack directly rather than through an API key: it holds its own shielded LEZ account, and the ceiling on what it may spend is not a check inside the agent process but state on chain that the agent's own program is the only thing permitted to write. Amended after a read of all seventeen documents in the repository, which turned up five statements in this file that the chain contradicts. Four of them understated the work: - the settlement counts said eleven, twelve and thirteen in three places; the manifests hold sixteen rows, thirteen under the shipped program, confirmed by re-decoding each from the chain's own copy; - the storage skills were listed as never having driven a live node from inside the module. They do — the module opens its own Logos Storage node and all four are called through invoke(); - the owner-approval path was called "the most serious open defect" and said to remove "half of the spending-threshold design". It ran on the public testnet: approve_spend in block 10776, spend_approved in 10786, the payee 4 to 6. What is actually closed is narrower and is now what this file says. Nothing was reworded to sound better; every replacement states what was measured, and the two explorer links added were opened before being cited. --- solutions/LP-0008.md | 428 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 428 insertions(+) create mode 100644 solutions/LP-0008.md diff --git a/solutions/LP-0008.md b/solutions/LP-0008.md new file mode 100644 index 0000000..b90827d --- /dev/null +++ b/solutions/LP-0008.md @@ -0,0 +1,428 @@ +# Solution: LP-0008 — Autonomous AI Module with Wallet, Storage, and Messaging + +**Submitted by:** edenbd1 + +> **Where to find what.** Every claim below carries the command that re-derives +> it; the long form of each is in the repository, linked. +> +> | To check | Go to | +> |---|---| +> | three agents live on the public testnet, and one paying another | [Summary](#summary) and [Repository](#repository) — explorer links, not hashes to paste | +> | that it runs from a clean clone | [The four commands](#the-four-commands-that-check-the-rest) — four lines, all exit 0 | +> | the recorded demo, and the e2e green in CI | [Supporting Materials](#supporting-materials) and the Supportability entries in the [checklist](#success-criteria-checklist) | +> | **what does not work** | the list at the end of [Summary](#summary), and [`docs/limitations.md`](../docs/limitations.md) | + +## Summary + +An agent that participates in the Logos stack directly rather than through an API +key: it holds its own shielded LEZ account, and the ceiling on what it may spend +is not a check inside the agent process but **state on chain that the agent's own +program is the only thing permitted to write**. + +The core idea is one design decision. An agent runs unattended on a remote node +and holds its own signing key, so any spending rule the agent evaluates can be +evaluated differently by whoever holds the process. So the rule is not evaluated +by the agent at all. Each agent has exactly one policy account, at +`PDA(program, "agent-policy/v1", agent_id)` — the program and the agent, and +nothing else — and the owner, both limits, the period and the running total live +in that account's data, which LEZ rule 6 (`UnauthorizedDataModification`) lets +only this program write. Anchoring one takes two signatures: the agent signs +`claim_agent` to name the account that may bind it, and only that account's +signature is accepted by `create_policy`. `create_policy` is +`#[account(init, …)]`, so the first anchor for an agent is the only anchor for +that agent — a second is not *detected*, it is impossible. `spend` derives the +same address from the *paying* account's id out of the pre-state, so there is no +argument to lie about, and it reads the limits off the account rather than from +the call. + +**Three agents are anchored and live on the public LEZ testnet**, one per default +skill category, each with its own shielded account and its own spending envelope: + +| category | agent id | policy account | per-tx | per-period | `create_policy` on chain | +|---|---|---|---|---|---| +| storage | `9XpkkvosC14TKTNZAoUdKXJwCheJ3dF8u3Xoojfv1FaE` | `6FscNXjNhamSCTbzLe67gU3noFHkQKDjRmD4tNj3ipSe` | 50 | 500 | [`6857ba23…631fe7d4`](https://explorer.testnet.lez.logos.co/transaction/6857ba2378a84ba51618582e852e3827a872e3ea85f17de76bdb45b1631fe7d4), block 8868 | +| messaging | `GpRdooEWJjX4JmRyT2n5KzMnDKtCM2HrvZ8iwMZpe5FS` | `7HH46tXhgfrMSSzWwpNrjkqujCB9EGA5cEvnYK1dA7bp` | 25 | 250 | [`ce557a0a…278e1918`](https://explorer.testnet.lez.logos.co/transaction/ce557a0a8adc517b60496c35514e269fff92a4393b90bef41ce10916278e1918), block 8876 | +| blockchain | `A7UBoMbSoQXNaDTiSjbr28KjedNrvBvroiamrc39JtMu` | `2RK4dPwzDTAdgjUGpGsCkok962StYpPV14QpW3Wusvc9` | 200 | 1,000 | [`2f6b481c…ecec5eda`](https://explorer.testnet.lez.logos.co/transaction/2f6b481cffde2adaeed9442c19599c939d97da0c930b70b45d97ac34ecec5eda), block 8884 | + +They have **paid each other for priced skills, unattended**, with the per-period +total accumulating on chain: sixteen settlements in all, of which **thirteen are +under the program this repository ships** — the messaging agent paying the +storage agent seven times, the storage agent paying the blockchain agent four +times, the blockchain agent paying the storage agent once, and one paid to a +shielded payee. One of those payments was made **by a module a host loaded**, in the same +call that discovered the payee's signed Agent Card and opened the A2A task: +settlement +[`ed8c3514…374b8cb3`](https://explorer.testnet.lez.logos.co/transaction/ed8c351412409c81723ea7b90e2d9cdcb0841a33234894bfff8269af374b8cb3), +block 9477. Every hash, block and balance is in +[Repository](#repository) below, generated from the chain rather than typed. + +**What is not delivered is stated plainly.** All twenty-three of the prize's +success criteria are now met, the last of them — the recorded video demo — by +one narrated walkthrough published with this submission. That is not a claim +that nothing is missing. Disclosed at the same volume as everything else, and +expanded in [`docs/limitations.md`](../docs/limitations.md): + +- the **three agents published here** can never have an above-threshold spend + approved: their owners anchored while their accounts were still unclaimed, and + such an account is filtered out of every later post-state. That is + irreversible for those three. It is not a property of the chain — an owner + claimed before it anchors signs indefinitely, and the whole path ran on the + public testnet ([`approve_spend`](https://explorer.testnet.lez.logos.co/transaction/4104dde4f504d42862ac89056e2476c414c4342dc145934c8a238382863841d8) + block 10776, [`spend_approved`](https://explorer.testnet.lez.logos.co/transaction/c243eaedfcbba87dc11d5ad28aad4f8424916d087adf8c811747169668169597) + block 10786, payee 4 → 6) against a fourth agent provisioned for it; +- the storage skills **have** driven a live node from inside the module — the + module `dlopen`s `libstorage` and opens its own node on + `meta.configure("storage","on")`, and `./scripts/skills-live.sh` calls all four + through `invoke()` from an empty `SkillPorts`. What is missing is the evidence + discipline the other node runs have: no transcript is committed for it and no + CI job runs it, unlike `artifacts/e2e/exercise-nodes.txt`; +- an inbound A2A task request is not automatically dispatched to the skill it + names. That is about inbound auto-serving, not about skill dispatch, which the + module has and the prize puts in scope: `invoke()` is the single dispatcher + every capability sits behind; +- no model has run against the inference port. The prize puts the choice of model + **out of scope** and asks only that inference be pluggable, which it is — a + local and an HTTP backend behind one port — but neither has served a real + request here. + +## Repository + +- **Repo:** +- **License:** dual MIT / Apache-2.0 (both full texts committed) +- **Default branch:** `main` + +Everything here is verifiable from a clean clone plus the public sequencer. No +claim depends on trusting the author. + +### The four commands that check the rest + +Run from a clean clone against the tip of `main`. These exit codes were observed +on a fresh clone of the public repository, not intended. + +```console +$ ./scripts/demo.sh # exit 0 +$ ./scripts/verify-deployment.sh # exit 0 +$ ./scripts/check-docs.py # exit 0 +$ ./scripts/submission-evidence.py --check SUBMISSION-DRAFT.md # exit 0 +``` + +**`./scripts/demo.sh` needs no key, no funded account and no local sequencer** — +only a Rust toolchain, `python3` and `curl`, and it names any of them that are +missing before it runs anything. It runs the policy tests, recomputes the +deployed program's hash from the committed binary, asks the public sequencer +whether that transaction exists, asks the same sequencer about a hash that +*cannot* exist, and replays the adversarial attack against both the superseded +program and the shipped one. Without the null control the first question would +prove nothing: an RPC that answered non-null to everything would pass it just as +happily. Thirteen checks print `OK`, none prints `FAIL`, and it closes on + +``` +OK the committed program refuses each attack, with the documented code + +demo complete — every claim above was computed or fetched here, not asserted. +``` + +### Evidence on the public testnet, generated rather than typed + +**The three tables below are reproduced from the output of +`./scripts/submission-evidence.py`.** That script fetches every figure from the +committed binary and from `https://testnet.lez.logos.co`, derives the deploy +transaction from the committed bytes rather than quoting it, reads the manifests +by column name, confirms every transaction it cites is inside the block it names +and absent from **both** neighbours, and exits non-zero if any of that fails. +`--check` re-runs the comparison against a document without writing, so a stale +copy cannot be produced. It runs in CI on every push. Regenerate them yourself: + +```console +$ ./scripts/submission-evidence.py +``` + +Nothing in these tables was transcribed by hand. Where a fact moves — CI state, +a period's running total — this document gives the command to ask rather than a +number. + +#### The program, and the three agents + +The deployed program is +[`697746f5…cb5370bf`](https://explorer.testnet.lez.logos.co/transaction/697746f52ff24019dbde4861c3649f49426904617840139a5405aa24cb5370bf). +A LEZ deploy hash is `SHA256(u32_le(len) || bytecode)`, so +`artifacts/programs/agent_verifier.bin` **is** its own deploy transaction — +recompute it and compare, which `./scripts/demo.sh` does in front of you. + +The three agents, their limits and the `create_policy` that anchored each are in +the table under [Summary](#summary), every hash a link to the block explorer. +Their claim transactions, policy-account addresses, owner ids and the byte-level +record layout are in +[`docs/criteria-evidence.md`](../docs/criteria-evidence.md#the-program-and-the-three-agents-at-length) +and re-read from the chain by `./scripts/verify-deployment.sh`. + +#### The settlements + +Sixteen settlements are recorded in [`artifacts/a2a-task.tsv`](../artifacts/a2a-task.tsv) +and [`artifacts/shielded-settlement.tsv`](../artifacts/shielded-settlement.tsv); +thirteen are under the shipped program, where the criterion asks for two. Each is +re-decoded from the chain's own copy of the transaction rather than from the +manifest, by `./scripts/verify-deployment.sh`, which also labels the rows a +redeploy orphaned instead of counting them. + +The one the video ends on: +[`54f85182…e2f47115`](https://explorer.testnet.lez.logos.co/transaction/54f851825f171cf62f6b4723f7133687f3d9dff7e138417374cc7960e2f47115), +block 10102 — the recipient goes 107 → 108 LEZ, and no owner signs anything. +Every row, with its before/after balances and the program that owned the ledger +it charged, is in +[`docs/criteria-evidence.md`](../docs/criteria-evidence.md#the-settlements-in-full). + +## Approach + +### The spending limit is an account, not an `if` + +A limit enforced inside the agent is enforced by whoever controls the agent's +process — which, for an agent on a remote node holding its own key, is not +necessarily the owner. So it is moved out of the process entirely. + +`create_policy` initialises exactly one account per agent, at +`PDA(program, "agent-policy/v1", agent_id)`, and it is `#[account(init, …)]`: +the first anchor for an agent is the only anchor possible, not merely the only +one detected. Only the program may write that account's data (LEZ rule 6), and +`spend` derives the address from the *paying* account out of the pre-state, so +there is no argument to lie about. The full argument, with the refusal codes and +the four deployments it took to get there, is in +[`docs/criteria-evidence.md`](../docs/criteria-evidence.md#approach-the-spending-limit-at-length). + +### What was tried and did not work, and why Logos + +Four deployments were needed to get the anchoring right, and each earlier one was +walked around by an attacker who was not lying — they really were the owner of +the policy they anchored; they had simply never been asked whether the agent +agreed. The full account, including the attack transaction that the superseded +program accepted and the one today's program refuses, is in +[`docs/criteria-evidence.md`](../docs/criteria-evidence.md#approach-what-was-tried-and-why-logos). +`./scripts/demo.sh` section 5 replays it against both programs in front of you. + +## Design Write-up + +The prize names seven topics. Each has a document in the repository that carries +it at full length; what follows is the decision each one turns on, so this +section reads in five minutes and the document is opened only where it matters. + +**Module architecture** — [`docs/architecture.md`](../docs/architecture.md). +A Logos Core plugin exposing three skill categories, each a thin binding onto a +real Logos node or onto LEZ. `invoke()` is the single dispatcher every capability +sits behind, which is what lets a second Logos app drive the owner's end without +the module exporting anything else. No skill links a library: each takes a struct +of `std::function`s — `DeliveryPort`, `StoragePort`, `WalletPort`, `ProgramPort` +— so every skill has a test against a fake port and there is one place where a +real node is wired. + +**Skill interface design** — [`docs/skills.md`](../docs/skills.md). +A skill is a class with `name()`, `parameterSchema()` and `invoke(json)`, added +through `registerSkill` without touching the core module. Schemas are declared +once and the Agent Card is generated from the registry rather than written by +hand, so a card cannot advertise a skill the module does not have. + +**Spending threshold mechanism** — [Approach](#approach) above has the argument; +[`docs/security-model.md`](../docs/security-model.md) has the mechanism, the +refusal codes, and what a holder of the agent's key can and cannot do. + +**Agent-to-agent coordination protocol** — [`docs/a2a-binding.md`](../docs/a2a-binding.md). +Agent Cards follow the A2A schema, tasks follow the A2A lifecycle, and Logos +Messaging is the transport A2A leaves open. Payment is the part A2A omits: the +client pays the price the card advertises, signed by the agent's own shielded +account, with no owner in the loop. + +**Security model** — [`docs/security-model.md`](../docs/security-model.md). +Anchoring takes two signatures: the agent signs `claim_agent` to name the account +that may bind it, and only that account is accepted by `create_policy`, which is +`#[account(init, …)]` — so the first anchor is the only one possible, not merely +the only one detected. What is *not* closed is enumerated there too: the balance +is held by the transfer program, so the agent's key can move it by calling that +program directly. This program bounds what the agent moves *through it*. + +**Known limitations** — [`docs/limitations.md`](../docs/limitations.md), where +anything that does not work is written down first, with the retractions of claims +that did not survive checking. + +**Integration instructions** — [`docs/DEPLOYMENT.md`](../docs/DEPLOYMENT.md) for +the chain side, [`docs/basecamp.md`](../docs/basecamp.md) for loading the module +into Logos Basecamp, including what a `.lgx` must satisfy to load at all. + +## Success Criteria Checklist + +Twenty-three criteria, mirrored from the prize in its own order and its own +words. **Tally: 23 MET, 0 UNMET** — Functionality 11 of 11, Usability 2 of 2, +Reliability 3 of 3, Performance 1 of 1, Supportability 6 of 6. + +Each entry gives the verdict and the one thing that re-derives it. The long form +of every one — the controls, the transcripts, what was watched failing — is in +[`docs/criteria-evidence.md`](../docs/criteria-evidence.md), copied there +unchanged. + +**Functionality** + +- [x] **MET — The agent module loads and runs inside Logos Core alongside the wallet, storage, and messaging modules without requiring modifications to those modules.** + All three companions are built from their published sources and all four modules load in one runtime, with both negative controls firing. Green on Linux in [run `32040423074`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/actions/runs/32040423074). [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — The agent has its own shielded LEZ account and can send and receive tokens independently of the owner's wallet.** + *Send*: 13 settlements under the shipped program, each signed by the agent's own shielded account. *Receive*: [`5942d6cd…`](https://explorer.testnet.lez.logos.co/transaction/5942d6cd6d223fd5bc7b5abd3bf34a1c1fc8e540e508232411e60e4d53a03d61) pays it at its shielded keys. [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — The owner can deploy the agent and configure it with a single CLI command on any machine using Logos Core headless.** + `./scripts/deploy-and-configure.sh` — one command, deploy through configure, on a machine with no Logos install. [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — The owner can interact with the agent in real time from a separate Logos app instance using Logos Messaging, with no intermediary server.** + Two LogosBasecamp processes, each with its own user dir and its own loaded copy, exchanging over Logos Messaging with no server between them. [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — The spending threshold mechanism correctly holds above-threshold transactions for owner approval and executes below-threshold transactions autonomously.** + Below the ceiling executes unattended; above it refuses with `Program error 6005` and needs an approval the owner signed. Both halves are in the e2e run and in the video. [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — All default skills listed above are implemented and documented.** + Every skill the prize lists is registered and documented in [`docs/skills.md`](../docs/skills.md), and `./scripts/check-docs.py` holds the catalogue to the registry rather than to prose. [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — Agent-to-agent coordination is A2A-compatible: Agent Cards follow the A2A schema, task interactions follow the A2A task lifecycle, and the implementation is documented as an A2A transport binding over Logos Messaging.** + Cards follow the A2A schema, tasks follow the A2A lifecycle, and the transport binding is specified in [`docs/a2a-binding.md`](../docs/a2a-binding.md). [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — Two or more agents can discover each other via Agent Cards, execute a task following the A2A lifecycle, and transfer LEZ payment autonomously, without owner intervention.** + `./scripts/delivery-in-plugin.sh settle` does all three in one invocation, and the settlement it produces is on chain with no owner signature. [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — At least 3 of the illustrative use cases above are demonstrated end-to-end on LEZ testnet.** + Four run end to end in the recorded demo: marketplace, notary, event alerter, spending threshold. [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — Three separate agents are deployed on LEZ testnet — one per default skill category (Storage, Messaging, and Blockchain) — each with a demonstrated, reproducible deployment and evidence provided.** + Storage, messaging and blockchain, each with its own shielded account and its own anchored envelope; the three `create_policy` links are in [Summary](#summary). [Evidence](../docs/criteria-evidence.md#functionality). + +- [x] **MET — Full documentation — including the skill interface spec, deployment guide, and owner interaction guide — and a clean public repository are delivered.** + `./scripts/check-docs.py` resolves every path, link and citation across fifteen documents. Public, under MIT / Apache-2.0. [Evidence](../docs/criteria-evidence.md#functionality). + + +**Usability** + +- [x] **MET — Provide a documented skill interface (module/SDK) that can be used to add new skills without modifying the core agent module.** + `logos::agent::ISkill` plus `registerSkill()`, specified in [`docs/skills.md`](../docs/skills.md); a new skill needs no change to the core module. [Evidence](../docs/criteria-evidence.md#usability). + +- [x] **MET — The owner-facing interface is accessible from the Logos app (Basecamp) via the owner channel — local build instructions and loadable assets are provided.** + The owner console is a loadable `app/agent-ui.lgx` with local build instructions in [`docs/basecamp.md`](../docs/basecamp.md). [Evidence](../docs/criteria-evidence.md#usability). + + +**Reliability** + +- [x] **MET — The agent module recovers from transient failures (network interruptions, node restarts) without losing pending task state.** + `module/tests/module_recovery_test.cpp` destroys the module mid-task and rebuilds it over the same directory; the pending task comes back. [Evidence](../docs/criteria-evidence.md#reliability). + +- [x] **MET — Above-threshold transactions that fail to reach the owner for approval are not executed — the agent retries notification before timing out and reports the failure.** + The agent retries the notification, times out rather than executing, and reports the failure — all three clauses demonstrated through Logos Core's own transport. [Evidence](../docs/criteria-evidence.md#reliability). + +- [x] **MET — Skill failures are isolated: a failing skill does not crash the module or affect other concurrently running skills.** + `invoke()` catches everything a skill can throw, returns the failure as JSON naming the skill, and leaves concurrent skills running. [Evidence](../docs/criteria-evidence.md#reliability). + + +**Performance** + +- [x] **MET — Document the compute unit (CU) cost of each on-chain operation the agent performs (token transfers, program calls, deployments) on LEZ devnet/testnet. Note: LEZ's per-transaction compute budget may change during testnet.** + [`docs/benchmarks/cu-budget.md`](../docs/benchmarks/cu-budget.md), which is candid about the premise: LEZ v0.2.4 does not meter compute units, and the search establishing that is in the file. [Evidence](../docs/criteria-evidence.md#performance). + + +**Supportability** + +- [x] **MET — The agent module is deployed and tested on LEZ devnet/testnet.** + Deployed at [`697746f5…`](https://explorer.testnet.lez.logos.co/transaction/697746f52ff24019dbde4861c3649f49426904617840139a5405aa24cb5370bf) and re-read from the chain by `./scripts/verify-deployment.sh`. [Evidence](../docs/criteria-evidence.md#supportability). + +- [x] **MET — End-to-end integration tests run against a LEZ sequencer (standalone mode) and are included in CI.** + [Run `32024953786`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/actions/runs/32024953786) — **success, 3 h 03**, `RISC0_DEV_MODE: 0`, no skip path: it refuses a runner it cannot finish on rather than skipping the proving. [Evidence](../docs/criteria-evidence.md#supportability). + +- [x] **MET — CI must be green on the default branch.** + Green on `main`; the badge is not the check, `gh run list` is. [Evidence](../docs/criteria-evidence.md#supportability). + +- [x] **MET — A README documents end-to-end usage: deployment steps, agent configuration, and step-by-step instructions for deploying and interacting with the agent via CLI and the Logos app owner channel.** + `README.md` is a runnable walkthrough — every section is a command with its output, not a description of one. [Evidence](../docs/criteria-evidence.md#supportability). + +- [x] **MET — A reproducible end-to-end demo script is provided and works against a real local sequencer with `RISC0_DEV_MODE=0`.** + `scripts/e2e-local-sequencer.sh`, which is what the CI run above executes. [Evidence](../docs/criteria-evidence.md#supportability). + +- [x] **MET — A recorded video demo of the end-to-end flow is included in the submission; the recording must show terminal output (including proof generation) to confirm `RISC0_DEV_MODE=0` was active.** + — one narrated walkthrough, 21 m 57 s, public testnet, `RISC0_DEV_MODE=0` legible throughout, four use cases. [Evidence](../docs/criteria-evidence.md#supportability). + +## FURPS Self-Assessment + +### Functionality + +The agent holds a shielded LEZ account, signs its own +transactions, and spends under a ceiling the chain keeps in state only its own +program may write. It can also be *paid* at that account, by the keys its signed +card publishes rather than by an id, so a settlement can hide both ends. Every +default skill is implemented and registered, and the registry is asserted against +the loaded binary rather than the source, because this repository has shipped +skills that were implemented, documented and unreachable. A2A discovery, the task +lifecycle and settlement are one call rather than three. + +### Usability + +A new skill is a class with three methods and a `registerSkill` +call; the core module is not touched. The owner's end is three registered skills +behind `invoke()`, which is why a second Logos app can drive it with nothing else +exported. One command deploys and configures. + +### Reliability + +Pending task state survives the module being destroyed and +rebuilt over the same directory. An above-threshold payment whose approval never +reaches the owner is not executed — it retries, times out and reports. A skill +that throws is caught, named, and does not take the module or a concurrent skill +with it. + +### Performance + +LEZ v0.2.4 does not meter compute units, and +[`docs/benchmarks/cu-budget.md`](../docs/benchmarks/cu-budget.md) says so with the +search that establishes it, rather than inventing a number. What is measured +instead is what actually costs: a `claim_agent` proof at ~54 minutes on a +four-core runner, `create_policy` at about one block. + +### Supportability + +Ten jobs on every push, an end-to-end run against a real +standalone sequencer with `RISC0_DEV_MODE=0` and no skip path, and gates that +hold the documents to the code — `check-docs.py` resolves every path and citation +across fifteen documents, `check-package-fresh.py` refuses a package whose binary +has lost a source literal, `write-program-record.py` refuses a source that has +moved under the deployed program. + +**What is weakest, stated here rather than found later.** The three agents +published here can never have an above-threshold spend approved — their owners +anchored while unclaimed, which is irreversible for them; the path itself works +and has run on chain against a fourth agent, and the ordering requirement it +implies is written up in full. An inbound A2A request is not dispatched to the +skill it names. The storage skills +have never driven a live node from inside the module. No model has run against +the inference port. Each is expanded in +[`docs/limitations.md`](../docs/limitations.md). + +## Supporting Materials + +- **Video demo:** **** — one narrated walkthrough, 21 m 57 s, + four illustrative use cases, against the public testnet at + `https://testnet.lez.logos.co` and never a localnet, with `RISC0_DEV_MODE=0` + legible throughout the proving output. The same file is a release asset of this + repository, [`lp8-demo.mp4`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/releases/download/demo-v1/lp8-demo.mp4), so the + evidence does not depend on a third party keeping it up. + `./scripts/check-video.py` reads the terminal text off the pixels and asserts + all of that rather than describing it. +- **Reproduce from a clean clone, no keys and no funds:** `./scripts/demo.sh` · + `./scripts/verify-deployment.sh` · `./scripts/check-docs.py` +- **Reproduce the deployment and the settlements** (needs a funded testnet + signer): `./scripts/deploy-agents.sh` · `./scripts/a2a-task.sh` · + `./scripts/e2e-local-sequencer.sh` · `./scripts/delivery-in-plugin.sh settle` +- **On-chain evidence:** every hash, block and explorer link is in + [Repository](#repository), generated rather than transcribed, and deliberately + not repeated here. Manifests, read **by column name**: + [`agents.tsv`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/blob/main/artifacts/agents.tsv) · + [`anchored.tsv`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/blob/main/artifacts/anchored.tsv) · + [`a2a-task.tsv`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/blob/main/artifacts/a2a-task.tsv) · + [`shielded-settlement.tsv`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/blob/main/artifacts/shielded-settlement.tsv) +- **Documentation:** [`docs/`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/tree/main/docs) — architecture, skills, + security model, A2A binding, deployment, Basecamp loading, CU budget, and + [`limitations.md`](https://github.com/edenbd1/lp-0008-autonomous-agent-module/blob/main/docs/limitations.md), which is where anything + that does not work is written down first. + +## Terms & Conditions + +By submitting this solution, I confirm that I have read and agree to the +[Terms & Conditions](../TERMS.md).