lambda-prize/prizes/LP-0008.md

LP-0008: Autonomous AI Module with Wallet, Storage, and Messaging [OPEN]

Logos Circle: N/A

Overview

This prize is for a Logos Core module that runs an autonomous AI agent with native access to the full Logos stack: a LEZ wallet, Logos Storage, and Logos Messaging. The agent has its own identity and funds, can communicate with its owner via chat, and can communicate with other agents. The owner deploys the agent on a remote node with a single CLI command and interacts with it from any Logos app instance on their laptop — no server configuration, no exposed APIs, no custodian.

The agent is not a chatbot wrapper. It is a first-class participant in the Logos ecosystem: it can hold and spend tokens, store and retrieve files, sign into token-gated groups, delegate tasks to peer agents, and take autonomous on-chain actions — all within limits set by its owner.

Motivation

AI agents need infrastructure: compute, storage, wallets, and communication channels. Today those are supplied by centralised cloud providers who control data, charge rent, and impose identity requirements. Logos provides all four natively in a privacy-preserving, censorship-resistant way — but no module yet exists to wire them together for autonomous agents.

A Logos-native agent module changes what an agent can do: it can receive funds from any Logos user, pay for storage privately, join token-gated communities on its owner's behalf, coordinate with other agents over encrypted messaging, and take on-chain actions without a custodian. The result is an agent that is genuinely sovereign — it owns its resources, controls its keys, and communicates over infrastructure no single party controls.

A competitive prize is the right mechanism because the design space — agent runtime, skill interface, spending controls, agent-to-agent protocol, and deployment UX — admits many valid approaches, and the best design will be discovered through competition rather than top-down specification.

Relationship to the A2A Protocol

The Agent2Agent (A2A) protocol — an open standard now governed by the Linux Foundation, originally contributed by Google — defines how agents discover each other (Agent Cards), negotiate tasks (Task lifecycle), and exchange messages (text, files, structured data). It is backed by over 150 organisations and is the emerging industry standard for agent interoperability.

A2A deliberately omits two things: payment and encrypted transport. Both are open problems it leaves to the implementer. Logos solves both natively — LEZ provides per-task micropayment, and Logos Messaging provides end-to-end encrypted transport with no central server.

This prize requires the agent-to-agent coordination layer to be A2A-compatible: Agent Cards must follow the A2A schema, and task interactions must follow the A2A task lifecycle. Logos Messaging replaces A2A's HTTP transport, and LEZ token transfers fill the payment gap. The result is an A2A-compatible agent network that any A2A client can discover and interact with, extended with payment and privacy primitives no other A2A implementation provides.

Agent Architecture

A conforming agent must implement the following architecture:

• Logos Core module: packaged as a dynamically loadable Logos Core module, following the Qt Remote Objects module interface. The agent module is loaded and managed by the Logos Core runtime alongside other modules (wallet, storage, messaging).
• Identity: the agent holds its own shielded LEZ account (NPK/ISK keypair). Its Logos Messaging address is derived from this identity. The agent is indistinguishable on-chain from any other account holder.
• Owner channel: the agent maintains a dedicated, end-to-end encrypted Logos Messaging topic with its owner. The owner can reach the agent from any Logos app instance that holds the owner's keys.
• Spending threshold: the owner configures a per-transaction and per-period token limit below which the agent acts autonomously. Above the threshold, the agent sends the proposed transaction to the owner via chat and waits for approval before submitting.
• Skill interface: agent capabilities are defined as discrete, composable skills. The submission must include a documented skill interface so that third parties can add skills without modifying the core module.

Default Skills

The following skills must be included in the submission:

Storage

• storage.upload(path, label) — encrypts and uploads a local file to Logos Storage; returns a content address.
• storage.download(address, path) — retrieves and decrypts a file from Logos Storage to a local path.
• storage.list() — lists files the agent has stored, with labels and content addresses.
• storage.share(address, recipient) — shares access to a stored file with another Logos identity.

Messaging

• messaging.send(recipient, message) — sends a message to a Logos Messaging address (user or agent).
• messaging.join(group_id) — joins a Logos Messaging group topic.
• messaging.create_group(members) — creates a new group topic and invites members.

Blockchain

• wallet.balance() — returns the agent's current shielded token balance.
• wallet.send(recipient, amount) — sends tokens to a Logos address; enforces the spending threshold (requests owner approval if exceeded).
• wallet.history() — returns a summary of recent transactions.
• program.query(program_id, params) — reads state from a LEZ program.
• program.call(program_id, instruction, params) — submits a transaction to a LEZ program; subject to spending threshold.
• program.deploy(binary_path) — deploys a compiled LEZ program binary to the network and returns the program ID.

Agent coordination (A2A-compatible)

Agent-to-agent communication follows the A2A protocol, with Logos Messaging as the transport and LEZ as the payment layer.

• agent.card() — returns this agent's A2A-compatible Agent Card: a signed JSON document declaring identity, skills, input/output schemas, and the LEZ price (if any) per task. Published to a Logos Messaging discovery topic.
• agent.discover(topic) — fetches Agent Cards published by other agents on a named Logos Messaging topic; returns a list of agents and their declared skills.
• agent.task(agent_address, skill, params) — sends a task request to another agent following the A2A task lifecycle (working → input-required → completed/failed); pays the declared LEZ price on task acceptance.
• agent.subscribe(agent_address, task_id) — subscribes to streaming status updates for a running task, delivered over Logos Messaging.
• agent.cancel(agent_address, task_id) — cancels an in-progress task and triggers any applicable refund.

Meta

• meta.skills() — lists all available skills and their parameters.
• meta.status() — reports the agent's current state: balance, storage usage, active tasks.
• meta.configure(key, value) — updates runtime configuration (e.g., spending threshold, owner address).

Illustrative Use Cases

Submissions are not required to implement all of these, but the default skills above must be sufficient to support them:

• Personal file vault: owner sends files to the agent via chat; agent encrypts, stores on Logos Storage, and responds with a content address. Owner can retrieve from any device.
• DAO voting delegate: agent monitors a governance contract for new proposals, evaluates them against owner-defined criteria, votes autonomously within policy, and messages the owner with a summary.
• Agent services marketplace: agents advertise skills on a shared discovery topic with a LEZ price; other agents discover, request, and pay for services autonomously.
• On-chain event alerter: agent monitors a LEZ program or account for state changes and notifies the owner via Logos Messaging.
• Multi-agent workflow: an orchestrator agent decomposes a task and delegates sub-tasks to specialist agents (e.g., a storage agent, a translation agent, a signing agent); results are aggregated and returned to the owner.
• Privacy-preserving notary: agent timestamps a document, uploads it to Logos Storage, and records the content address on LEZ — providing a verifiable, private proof of existence.
• Paid skill marketplace: agents publish Agent Cards with a LEZ price per task on a shared discovery topic. A client agent discovers a specialist (e.g., a translation agent, an OCR agent, a code-review agent), pays the declared price in LEZ, and receives the result — fully autonomous, no human in the loop, no payment processor.
• Cross-framework agent interoperability: because the coordination layer is A2A-compatible, agents built with other A2A-supporting frameworks (LangChain, Vertex AI, etc.) can discover and call Logos agents. Logos agents bring payment and privacy to those interactions that vanilla A2A cannot offer.
• Privacy-preserving agent pipeline: an orchestrator agent decomposes a sensitive task (e.g., document analysis) and routes sub-tasks to specialist agents over encrypted Logos Messaging channels — intermediate results are never exposed to a third-party server or observable on-chain.

Success Criteria

Functionality

• The agent module loads and runs inside Logos Core alongside the wallet, storage, and messaging modules without requiring modifications to those modules.
• The agent has its own shielded LEZ account and can send and receive tokens independently of the owner's wallet.
• The owner can deploy the agent and configure it with a single CLI command on any machine using Logos Core headless.
• The owner can interact with the agent in real time from a separate Logos app instance using Logos Messaging, with no intermediary server.
• The spending threshold mechanism correctly holds above-threshold transactions for owner approval and executes below-threshold transactions autonomously.
• All default skills listed above are implemented and documented.
• 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.
• 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.
• At least 3 of the illustrative use cases above are demonstrated end-to-end on LEZ testnet.
• At least 5 agents are deployed on LEZ testnet by parties outside the submitting team, each demonstrating at least one skill autonomously.
• Full documentation — including the skill interface spec, deployment guide, and owner interaction guide — and a clean public repository are delivered.

Usability

• Provide a documented skill interface (module/SDK) that can be used to add new skills without modifying the core agent module.
• The owner-facing interface is accessible from the Logos app (Basecamp) via the owner channel — local build instructions and loadable assets are provided.

Reliability

• The agent module recovers from transient failures (network interruptions, node restarts) without losing pending task state.
• 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.
• Skill failures are isolated: a failing skill does not crash the module or affect other concurrently running skills.

Performance

• 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.

Supportability

• The agent module is deployed and tested on LEZ devnet/testnet.
• End-to-end integration tests run against a LEZ sequencer (standalone mode) and are included in CI.
• CI must be green on the default branch.
• 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.
• A reproducible end-to-end demo script is provided and works against a real local sequencer with RISC0_DEV_MODE=0.
• 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.

Scope

In Scope

• A Logos Core module implementing the agent runtime, owner channel, spending threshold, and skill dispatch.
• A documented skill interface enabling third-party skill development.
• All default skills listed above.
• A CLI for agent deployment, configuration, and initial funding.
• A reference Logos app integration showing the owner chat interface.
• Documentation covering: module architecture, skill interface, spending controls, agent-to-agent protocol, deployment instructions, and the security model.

Out of Scope

• A specific AI model or inference backend — the module must support pluggable inference (local or API-based), but the choice of model is left to the deployer.
• A consumer-facing graphical UI beyond what the existing Logos app provides.
• Ongoing maintenance or security audits beyond initial delivery.

Prize Structure

• Total Prize: $1,200
• Effort: Large

Eligibility

Open to any individual or team. Submissions must be original work. Teams must hold the rights to all submitted code and agree to license it under MIT or Apache-2.0.

Submission Requirements

• Public repository with the Logos Core module, CLI, and all default skill implementations under MIT or Apache-2.0.
• Module loadable on LEZ testnet with a documented deployment procedure.
• End-to-end demo video(s) for at least 3 of the illustrative use cases, in which the builder narrates what they built and why, walks through the architecture and key implementation decisions, and demonstrates the full flow. A silent screencast is not sufficient (see demo requirements).
• Evidence of at least 5 third-party agent deployments on LEZ testnet (e.g., linked public activity, attestations, or on-chain records).
• Write-up covering: module architecture, skill interface design, spending threshold mechanism, agent-to-agent coordination protocol, security model (what the agent can and cannot do without owner approval), known limitations, and integration instructions.

Evaluation Process

Submissions are evaluated first-come-first-served against the success criteria. The first submission that satisfies all criteria wins.

Evaluators will independently clone the repository and run the demo script from a clean environment; the script must succeed without modification. Evaluators may also ask technical follow-up questions to verify authorship and understanding of the implementation.

The following policies apply to all prizes (see evaluation policies):

• Submissions: each builder (or team) is allowed a maximum of 3 submissions per prize, with at most one submission/review per week.
• Feedback: initial evaluation feedback is limited to a pass/fail indication against the success criteria.

Resources

• Logos Execution Zone repo
• Risc0 proving system
• Agent2Agent (A2A) Protocol Specification
• A2A GitHub repository
• LP-0002 — Private M-of-N Multisig (relevant for above-threshold approval flows)
• LP-0005 — Private Token Balance Attestation (relevant for token-gated group access by agents)

Potential for Subsequent λPrizes

This prize targets the current LEZ testnet. Should a future testnet version introduce breaking changes, a subsequent λPrize may be opened to cover the necessary adaptation and redeployment.