# Agents Need Receipts, Not More Tool Calls

Armanas Povilionis, Alithea Bio

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/Fu45geO3zX8-agents-need-receipts-not-more-tool-calls) · [Video](https://www.youtube.com/watch?v=Fu45geO3zX8)

## Agents Need Receipts, Not More Tool Calls

Froglet’s remote and local addition demos show how agents can discover external services, request work, and retain signed records across organizational boundaries.

Familiarity with API requests, Docker, and the Model Context Protocol (MCP) will help with the demonstrations.

### What makes scientific automation collaborative?

[0:01](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1s)

What would it take to automate scientific research that other researchers can trust and build on? At Alithea Bio, Armanas Povilionis works on immuno-oncology and immunopeptidomics, using agentic automation internally and providing it to clients. Scientific research is a compelling application for agents, but completing an individual task is only part of the problem.

Adding more tools does not supply the missing collaboration mechanism. Life sciences involves contributions from multiple participants, so a result needs a record of the steps behind it. Povilionis proposes a **verifiable chain of receipts**: successive records that make the work inspectable and provide a foundation for trust, repeatability, and collaboration.

![Dark slide with the statement “Agents need receipts, not more tool calls,” receipts highlighted in green, and a circular speaker inset.](https://ai.engineer/api/talk-essay-media/551f3a3530c2cb95281601a8932be25066c29d231397da83727cea8291aa5175)

Agents need receipts, not more tool calls.

Think of an agent as a cook. Better knives, more pans, and better ovens improve the speed and quality of work inside one kitchen. Scientific collaboration is closer to running a Michelin-starred restaurant: the outcome also depends on suppliers, the quality of their produce, coordinated services, and the ability to deliver the same quality repeatedly.

You cannot bring every supplier and service into the kitchen. **Repeatable collaboration depends on coordinating the supply chain**, including the parts outside your direct control. Local tool improvements help, but they do not establish that coordination.

### Give agents budgets for external work

[3:02](https://www.youtube.com/watch?v=Fu45geO3zX8&t=182s)

Agents already have growing collections of tools, while useful data, specialized analytics, and compute remain distributed across organizations. Povilionis’s proposed next step is to give agents budgets they can manage across those boundaries.

A token allowance for a task is an early version of this idea. A broader service budget would let an agent discover providers, request data, negotiate execution terms, and pay for work. The cook becomes an executive chef: selecting suppliers, ordering ingredients, coordinating execution, and keeping a record of what happened. This is a vision for how agents could operate as workflow automation matures.

[Froglet](https://froglet.dev/) is the open-source protocol being built to support those interactions with external data and service providers. Its scope is discovery, transactions, and verifiable receipts.

It sits between existing systems, integrating payment rails, agent harnesses, execution environments, and transport protocols. Participants need a **shared interface**, but they do not need identical underlying software stacks. That distinction lets an organization expose a service without adopting every other participant’s implementation.

The site presents local installation with one command and remote use with one prompt. These are entry points into the same protocol, allowing someone to try a hosted node before running one locally.

Povilionis characterizes bespoke, closed-source scientific collaborations as projects that can take years and cost millions before a reusable workflow exists. Froglet aims to reduce the integration effort after an organization has decided that a resource can be shared. Once exposed, the resource can be discovered by an agent, which can inspect its terms, request work, and receive a receipt.

After an organization has decided a resource is shareable, Povilionis estimates that exposing it through Froglet takes a few thousand tokens and minutes. These are his estimates of integration effort, not measured benchmarks; deciding what may be shared remains a prerequisite.

### One node, several roles, and a signed transaction

[7:03](https://www.youtube.com/watch?v=Fu45geO3zX8&t=423s)

The website walkthrough begins with documentation intended primarily for agents, alongside explanations for people. Its central architectural point is that the [Froglet node implementation](https://github.com/armanas/froglet) supports several roles.

| Role | Responsibility |
|---|---|
| Provider | Offers data or a service. |
| Requester | Requests work from a provider. |
| Marketplace | Offers marketplace services as another Froglet node. |

These are roles of the same node implementation, rather than separate software products that each participant must integrate.

The protocol’s responsibilities are deliberately limited: help participants find services, establish trust, pay, and prove that work happened. It does not replace the core functions of the tools and protocols underneath it.

Creating a node generates a **key pair** for identity and artifact signing. During execution, artifacts are signed into a chain. The intended property is tamper evidence: the chain remains valid only while its recorded data has not been altered.

**Editor’s note:** Froglet’s [threat model](https://github.com/armanas/froglet/blob/main/docs/THREAT_MODEL.md) distinguishes attributable records from correct results. Receipts do not prevent a provider from returning an incorrect result, so a valid chain alone cannot establish scientific correctness or reproducibility.

Discovery and execution follow different paths:

1. **Publish availability.** Providers publish their services to a marketplace using the Froglet protocol.
2. **Find a service.** A requester asks a known marketplace for its available service listings.
3. **Contact the provider directly.** Once the requester chooses a service, quote, deal, execution, and receipt proceed through the requester–provider interaction.

The marketplace helps the participants find each other; it is not an intermediary in the subsequent execution.

![Froglet walkthrough showing three connected role nodes beside explanatory text and populated terminal output.](https://ai.engineer/api/talk-essay-media/62b31f293eaac6af305ba7ded6966fc2513b33de73ca81cbfd768e2cb9f0cf98)

Provider, requester, and marketplace roles linked by deal, register, and discover connections.

So far, this is node-to-node communication. Agents enter through plugins in Froglet’s core that connect to execution environments and agent harnesses. Povilionis names OpenClaw, NemoClaw, and operation as an MCP server or plugin.

The intended human interface is an LLM. Whether someone wants to provide a service or request one, the agent drives the protocol interaction on their behalf.

### Remote trial: submit a deal and wait for its result

[10:44](https://www.youtube.com/watch?v=Fu45geO3zX8&t=644s)

The terminal demonstration proceeds through a hosted trial, a local Docker installation, and a **Claude** session that configures and invokes a local service. The hosted trial comes first, using a Froglet node running on a remote server.

Povilionis checks that the hosted trial responds, then creates a temporary requester token. The trial token lasts 15 minutes. He also obtains access to a provider whose service adds two numbers, and points to the different tokens as evidence of different nodes in the demonstration.

**Editor’s note:** The [current hosted-trial guide](https://froglet.dev/learn/cloud-trial/) says sessions share the node’s signing identity. Different access tokens alone do not establish different cryptographic identities.

The service call has three stages:

1. **Construct the payload.** Specify the schema, target service, provider, and inputs. The inputs here are `7` and `5`.
2. **Submit the request.** Send the payload to the remote Froglet node and obtain a deal ID. This is a handle for following the transaction; receiving an identifier is not, by itself, verification of a signed receipt.
3. **Wait for completion.** Use a loop to wait for the asynchronous execution to finish. Povilionis attributes possible delays to load on the small cloud trial node.

The remote addition service returns 12 for inputs 7 and 5. The distinction between accepting a transaction and completing its computation matters even in this small example: a deal can have an identifier before its result is available.

### Run locally and distinguish identity from role

[13:30](https://www.youtube.com/watch?v=Fu45geO3zX8&t=810s)

The next demonstration uses the website’s `/agent` bootstrap to run Froglet locally through Docker. Povilionis starts from an empty working directory, but the installer reports that the required components are already present and confirms that the node is running. The visible setup therefore is not a fresh-install timing measurement.

The local view appears to show two Froglets. Looking at their **node ID**, however, reveals the same identity in both entries: one node is simultaneously acting as provider and consumer.

This makes the earlier role model concrete. A role describes what a node is doing, not necessarily a separate deployment. Povilionis then shows the Docker listing, whose address and port match the local installation.

### Claude publishes and invokes the local service

[14:57](https://www.youtube.com/watch?v=Fu45geO3zX8&t=897s)

With the local node running, Povilionis opens Claude and confirms that Froglet MCP is enabled. He changes the session’s permissions to reduce interruptions during the demonstration, then constrains the task to Froglet MCP and adds: “Do not install anything.”

Instead of submitting each operation separately, he supplies the prepared steps together and asks for a specific output. Claude begins by checking what is running.

The requested workflow is:

1. **Check readiness.** Confirm live status and check that the provider and runtime are healthy.
2. **Publish the service.** Create an artifact from the template that adds two numbers.
3. **Discover and invoke it.** Find that service locally and call it with `5` and `7`.
4. **Await the result.** Allow for asynchronous completion, then display the requested output.

Claude executes the commands and reports the result. The local addition service returns 12 for inputs 5 and 7. The agent has handled both sides of the workflow: publishing the provider’s service and requesting its execution.

![Terminal summary showing inputs 7 and 5, succeeded deal status, sum 12, settlement details, and receipt-status flags.](https://ai.engineer/api/talk-essay-media/4c24abe549de0aa4b434cfc1d6e123072743f8d8dcb4b80d1651c4bc0eedb656)

Claude reports a successful addition call: 7 plus 5 returns 12.

### Put transaction machinery beneath the service interface

[17:33](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1053s)

The same service boundary could expose resources more useful than addition. Povilionis proposes two applications:

- **Database access:** Let an agent configure a service that provides access row by row for payment.
- **GPU computation:** Leave a GPU available in the background to accept computation requests.

These are proposed applications, not paid workloads demonstrated in the recording. **Editor’s note:** The [current local quickstart](https://froglet.dev/learn/quickstart/) describes test/regtest payment evidence and says real money has not moved.

The agent-facing surface is the service it needs to use. Receipts, payment, execution environments, negotiation, and marketplace functions sit underneath that surface. Povilionis describes this separation as reducing the need to load all the underlying tools and protocols into the LLM’s context. The benefit is architectural; no token-saving measurement accompanies it.

This connects the arithmetic demonstration back to scientific collaboration. An agent needs to find resources outside its organization, arrange remote execution, and retain a verifiable chain of what happened. Together, those capabilities let a workflow carry its record across organizational boundaries instead of ending at a successful local tool call.

Froglet’s proposed foundation for ongoing scientific automation is that combination of discovery, execution, and receipts. The demonstrations exercise the transaction path; the larger ambition is collaborative science whose successive contributions remain inspectable.

## Resources

- [Froglet](https://froglet.dev/) — Project overview with hosted trial, local installation, and protocol documentation.
- [Froglet source repository](https://github.com/armanas/froglet) — Open-source node implementation, agent integrations, protocol documents, and tests.
- [Froglet kernel specification summary](https://froglet.dev/spec/kernel/) — Explains signed artifact types, identity and signature formats, settlement methods, and protocol scope.
- [Froglet threat model](https://github.com/armanas/froglet/blob/main/docs/THREAT_MODEL.md) — Describes receipt guarantees, trust boundaries, payment risks, and key-compromise limitations.
- [Current hosted trial guide](https://froglet.dev/learn/cloud-trial/) — Instructions for the free hosted addition demo, session expiration, result polling, and receipt inspection.
- [Current local installation guide](https://froglet.dev/learn/quickstart/) — Docker-based bootstrap and MCP steps to publish and invoke a local addition service.

## Slides

### Agents need receipts

Froglet aims to provide verifiable receipts for each step, supporting trust, repeatability and collaboration in life sciences research.

[0:00](https://www.youtube.com/watch?v=Fu45geO3zX8&t=0s) [Title slide states that agents need receipts, not more tool calls.](https://assets.ai.engineer/sites/aiecode2025/sha256/2674aa0ee31190992c2ee52b3f2e3340651797136fbf30c768c6921a9eab4535.webp)

_0..0_ froglet project of Alithea bio

Agents need receipts,
not more tool calls.

### Restaurant supply chain

A kitchen sits amid suppliers and restaurant staff. Consistent dishes depend on aligning the whole supply chain, from the quality of produce to service.

[2:41](https://www.youtube.com/watch?v=Fu45geO3zX8&t=161s) [A kitchen surrounded by images of suppliers and restaurant staff.](https://assets.ai.engineer/sites/aiecode2025/sha256/df6482dbebf9de3b175059b67f502054597932efa50a1e44c7f24ee767519683.webp)

_0..0_ froglet
Alithea bio

### Agent surfaces and provider assets

Agent surfaces sit opposite provider assets such as data and compute. The speaker envisions agents managing budgets to access services across organizations.

[3:05](https://www.youtube.com/watch?v=Fu45geO3zX8&t=185s) [Two panels list agent surfaces and provider assets, with kitchen and ingredient images below.](https://assets.ai.engineer/sites/aiecode2025/sha256/f9d5a8d2f6b080124c81f9165f3da337f72d44674598b279abda575b3a0bf811.webp)

_0..0_ froglet
Alithea bio

AGENT SURFACES
• MCP / A2A-style calls
• OpenClaw / NemoClaw
• custom runtimes

PROVIDER ASSETS
• data
• compute
• analysis services

### Froglet and provider assets

Froglet is an open-source protocol being built for agents to discover and transact with external providers, then receive verifiable receipts. The slide connects those steps to data, compute, and analysis services.

[4:03](https://www.youtube.com/watch?v=Fu45geO3zX8&t=243s) [A cropped slide shows Froglet discovering, executing and getting a receipt from provider assets.](https://assets.ai.engineer/sites/aiecode2025/sha256/bb938ccac4c3887e2e8fcc269df1f6a649a2a1b9b572e3e576d40dfbd562ba69.webp)

FROGLET
• discover
• execute
• get receipt

PROVIDER ASSETS
• data
• compute
• analysis services

### Froglet demo and integrations

Froglet is designed to connect payment rails, execution environments and agent tools through a shared interface. The slide links to its demo.

[5:00](https://www.youtube.com/watch?v=Fu45geO3zX8&t=300s) [Froglet demo URL and QR code, surrounded by payment, runtime, and agent integration examples.](https://assets.ai.engineer/sites/aiecode2025/sha256/a8aefad40aa93e82275b06576db9b2399f51f8a3833114128a548609d121bf6d.webp)

_0..0_ froglet
Alithea bio

https://froglet.dev/demo/

Lightning
Stripe
x402

WASM
Python
Docker

Claude Code
Codex
MCP
OpenClaw

### Collaboration setup comparison

The slide contrasts scientific collaboration setup—years and millions—with Froglet’s claimed setup of a few thousand tokens and minutes.

[6:54](https://www.youtube.com/watch?v=Fu45geO3zX8&t=414s) [Slide compares the claimed time and cost of scientific collaboration setup with Froglet setup.](https://assets.ai.engineer/sites/aiecode2025/sha256/8b9038c9d20dbaacdd739f849ce8de75a34795f54f38e770d01a3bf63ae84647.webp)

_o..o_ froglet
Alithea bio

Scientific collaboration setup takes years and costs millions

froglet setup costs few thousand tokens and takes minutes.

### Froglet homepage demonstration

The homepage gives an AI agent a prompt to run demo.add and a witness/hash follow-up, then report results and receipt/feed proof. It also offers documentation and other test prompts.

[7:10](https://www.youtube.com/watch?v=Fu45geO3zX8&t=430s) [Froglet homepage showing an agent prompt, demonstration options, and a description of the protocol.](https://assets.ai.engineer/sites/aiecode2025/sha256/55f7cc4a6481bf1117c45d5c6cb116dde3c3ddcd24791f0159659139da33733b.webp)

FROGLET — IDENTITY. EXECUTION. SETTLEMENT.

Froglet is not for You.
It's for your AI Agent.

An open protocol for AI agents to sell and buy services — cryptographic identity, signed deals, executable work, and verifiable settlement. Trust through math, not middlemen.

Try in cloud
Run locally
Watch walkthrough →

LET THE AGENT PROVE IT

PROMPT FOR YOUR AI AGENT
Open https://try.froglet.dev/llms.txt. Run demo.add and one witness/hash follow-up. Report statuses, result, receipt/feed proof, mismatches, and what this proves or does not prove for my projects/data. If unreachable, say so.
COPY

Paste into Claude Code, Codex, OpenClaw, or any agentic client. The agent should come back with live evidence, not a product summary.

FAST PROOF
Hosted proof
COPY

STRICT AUDIT
Evidence audit
COPY

FOLLOW-UP
Proof + witness
COPY

LOCAL PATH
Install proposal
COPY

FEED
Receipt check
COPY

AGENT REPORT
No trust tour.
Make the model bring back evidence from the live service.

CATALOG
5 free demos
demo.add + witness/hash

RESULT
sum = 12
{a:7,b:5}

EVIDENCE
receipt + feed
descriptor · offer · receipt

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Fri Jun 26 18:53
Froglet-AI-Engineer-Research
Froglet — identity. execution.
froglet.dev
Work
_0..0_ froglet
Home  Docs  Marketplace  Managed  Open source  GitHub

### Froglet homepage

Froglet’s homepage offers a prompt for an AI agent to run demo.add and a witness/hash follow-up, then report results and receipt/feed proof.

[7:35](https://www.youtube.com/watch?v=Fu45geO3zX8&t=455s) [Froglet homepage describing an agent protocol, with a prompt for testing it.](https://assets.ai.engineer/sites/aiecode2025/sha256/7e688a28c31dc1d5a81f60a15f84b2ae2b243704b22f53dbfd623eed8e8b723e.webp)

FROGLET — IDENTITY. EXECUTION. SETTLEMENT.

Froglet is not for You.
It’s for your AI Agent.

An open protocol for AI agents to sell and buy services — cryptographic identity, signed deals, executable work, and verifiable settlement. Trust through math, not middlemen.

Try in cloud
Run locally
Watch walkthrough →

LET THE AGENT PROVE IT

PROMPT FOR YOUR AI AGENT
Open https://try.froglet.dev/llms.txt. Run demo.add and one witness/hash follow-up. Report statuses, result, receipt/feed proof, mismatches, and what this proves or does not prove for my projects/data. If unreachable, say so.
COPY

Paste into Claude Code, Codex, OpenClaw, or any agentic client. The agent should come back with live evidence, not a product summary.

FAST PROOF
Hosted proof
COPY

STRICT AUDIT
Evidence audit
COPY

FOLLOW-UP
Proof + witness
COPY

LOCAL PATH
Install proposal
COPY

FEED
Receipt check
COPY

AGENT REPORT
No trust tour.
Make the model bring back evidence from the live service.

CATALOG
5 free demos
demo.add + witness/hash

RESULT
sum = 12
{a:7,b:5}

EVIDENCE
receipt + feed
descriptor · offer · receipt

Interface text:
froglet
Home
Docs
Marketplace
Managed
Open source
GitHub
Chrome
File Edit View History Bookmarks Profiles Tab Window Help
Fri Jun 26 18:53
Froglet-AI-Engineer-Researc[illegible]
Froglet — identity. execution.
froglet.dev
Work
https://froglet.dev/demo/

### The network

Froglet uses the same node for provider, requester and marketplace roles. Providers register with a marketplace, requesters discover them, and the two parties make a deal.

[7:41](https://www.youtube.com/watch?v=Fu45geO3zX8&t=461s) [Provider, requester and marketplace diagram alongside completed node startup output.](https://assets.ai.engineer/sites/aiecode2025/sha256/e5859a0e74e3afe124b65630097a3541f8c373aedaeaa5cbce67bea418dccfb1.webp)

STEP 1 / 11
The network

Three roles, one protocol. Providers sell resources. Requesters buy them. Marketplaces help them find each other.
Learn more →

Every node can play multiple roles. A marketplace is itself a provider that sells search. There are no special node classes.

F^P
provider

deal

F^R
requester

register
discover

M
marketplace

Provider Froglet → F^P
Requester → F^R, Marketplace → M

froglet — zsh
~ ❯ FROGLET_PAYMENT_BACKEND=none FROGLET_PUBLISH_DEMO_SERVICES=1 cargo run --bin froglet-node
local assumption: 127.0.0.1:8080 and :8081 are free
STARTUP OUTPUT (ABRIDGED)
Local Runtime API: http://127.0.0.1:8081
Local API Gateway: http://127.0.0.1:8080
Node is now online and accepting traffic.
~❯

Back
Continue

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Fri Jun 26 18:53
Froglet-AI-Engineer-Researc[illegible]
Demo - Froglet
froglet.dev/demo/
froglet  Home  Docs  Marketplace  Managed  Open source  GitHub

### Signed artifacts

Six signed artifacts form a hash-linked chain from descriptor to receipt. The requester signs the deal; the provider signs the other artifacts. Tampering with one breaks the chain.

[8:38](https://www.youtube.com/watch?v=Fu45geO3zX8&t=518s) [A chain of six signed artifacts linked by hashes, with explanatory text and an example envelope.](https://assets.ai.engineer/sites/aiecode2025/sha256/ba34e977345265fc3edaca432d38384db4ce277fe0763769d496b6f4a339a687.webp)

STEP 4 / 11
Signed artifacts

Every interaction produces signed, hash-linked evidence. Six artifact types form a chain. Learn more →

RFC 8785 canonical JSON ensures identical bytes. SHA-256 hashed, BIP340 Schnorr signed. Each artifact references the previous by hash.

provider signs: descriptor
provider signs: offer
provider signs: quote
requester signs: deal
provider signs: invoice_bundle
provider signs: receipt

descriptor → H(a1) → offer → H(a2) → quote → H(a3) → deal → H(a4) → invoice_bundle → H(a5) → receipt

Each linked by SHA-256 hash. Tamper with one, chain breaks.

SIGNED ENVELOPE SHAPE (ABRIDGED)
{"artifact_type":"quote",
"payload_hash":"a3f19e2b...7d4c",
"signature":"<64-byte BIP340 Schnorr signature hex>"}
~❯

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Fri Jun 26 18:54
Froglet-AI-Engineer-Researc[illegible]
Demo - Froglet
froglet.dev/demo/
froglet  Home  Docs  Marketplace  Managed  Open source  GitHub
froglet — zsh
Back  Continue

### Discovery

Providers publish feeds to an optional marketplace, which verifies descriptors and indexes offers for requesters. Once a requester selects a service, it communicates directly with the provider.

[8:59](https://www.youtube.com/watch?v=Fu45geO3zX8&t=539s) [A provider publishes a feed to a marketplace that a requester can discover.](https://assets.ai.engineer/sites/aiecode2025/sha256/78ca8973f8f6d4acda2a30c13867f472e68746a90f79f085fb152d03546e8776.webp)

STEP 5 / 11
Discovery

A marketplace is optional. It indexes signed provider feeds so requesters can search. Learn more →

The marketplace is not a protocol root of truth. It consumes signed descriptors and offers; kernel quote, deal, receipt, and settlement semantics stay the same with or without it.

F^P
provider
publish feed →

F^R
requester
discover →

M
marketplace

M does:
1. verify signed descriptor
2. index bound offers
3. return provider URLs

froglet — zsh
~ ❯ curl
http://127.0.0.1:8080/v1/provider/services
SERVICES OUTPUT (ABRIDGED)
{"services":
[{"service_id":"demo.add","price_sats":0},
...]}
~❯

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Fri Jun 26 18:55
Froglet-AI-Engineer-Researc[illegible]
Demo - Froglet
froglet.dev/demo/
Work
_0..0_ froglet
Home  Docs  Marketplace  Managed  Open source  GitHub
Back  Continue

### The deal

The requester and provider communicate directly: they exchange a quote and signed deal, then execution returns a receipt. Each step is hash-linked.

[9:28](https://www.youtube.com/watch?v=Fu45geO3zX8&t=568s) [A requester and provider exchange a quote and signed deal, followed by execution and a receipt.](https://assets.ai.engineer/sites/aiecode2025/sha256/d4d8701f61fc6d7d55f755a3048af51d041c15170e839fea5be8dacb0e8a1d38.webp)

STEP 6 / 11
The deal

Search, quote, commit, execute, receipt. The complete lifecycle of one interaction.
Learn more →

The requester searches, picks a provider, gets a quote, signs the deal, workload executes, receipt returned. Every step is hash-linked.

F^R
requester

F^P
provider

1. request quote →
2. signed quote ←
3. signed deal →
4. execute + receipt ←

base fee locks on acceptance
success fee settles on success

froglet — zsh
RUNTIME DEAL REQUEST (ABRIDGED)
~ ❯ curl -H 'Authorization: Bearer <runtime-token>' -X POST http://127.0.0.1:8081/v1/runtime/deals --data '<full demo.add workload>'
DEAL OUTPUT (ABRIDGED)
{"deal":{"status":"succeeded",
"result":{"sum":12},
"receipt":{"payload":
{"execution_state":"succeeded","settlement_sta[illegible]
~❯

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Fri Jun 26 18:55
Froglet-AI-Engineer-Researc[illegible]
Demo - Froglet
froglet.dev/demo/
froglet  Home  Docs  Marketplace  Managed  Open source  GitHub
Back  Continue

### Agents and integrations

Agents reach a Froglet requester through MCP or OpenClaw; the requester then makes a deal with a provider. The MCP server uses stdio for local or self-hosted nodes, while agent tools call the same HTTP APIs.

[9:45](https://www.youtube.com/watch?v=Fu45geO3zX8&t=585s) [An agent connects through an integration to a requester, which makes a deal with a provider.](https://assets.ai.engineer/sites/aiecode2025/sha256/6b635fe90afb50d52f7009bae78f93249c1ce934292bfa04b55b7af06711ffff.webp)

STEP 10 / 11
Agents and integrations

AI agents use froglet through MCP, OpenClaw, NemoClaw, or raw HTTP. Learn more →

OpenClaw: Claude tool. NemoClaw: local LLM.
MCP Server: Claude Code, Cursor, Windsurf.
The kernel has signed deals; local and hosted API surfaces still use normal auth tokens.

Agent
Claude / GPT / Llama
→ MCP / OpenClaw →
F^R
requester
→ deal →
F^P
provider

Integrations:
OpenClaw    Claude tool interface
NemoClaw    local LLM agent
MCP Server  Claude Code, Cursor, Windsurf
HTTP        any client with normal API auth

froglet — zsh
~ ❯ npx froglet-mcp
INTEGRATION SUMMARY (NOT CLI STDOUT)
starts MCP server over stdio for local or
self-hosted nodes
agent tools still call the same
runtime/provider HTTP APIs
~❯

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Fri Jun 26 20:02
Froglet-AI-Engineer-Researc[illegible]
Demo - Froglet
froglet.dev/demo/
froglet  Home  Docs  Marketplace  Managed  Open source  GitHub
Back  Continue

### Terminal

The presenter introduces a remote Froglet trial with a 15-minute identity, then plans to run Froglet locally in Docker and have Claude configure and try a service.

[10:42](https://www.youtube.com/watch?v=Fu45geO3zX8&t=642s) [An empty terminal prompt with a presenter inset.](https://assets.ai.engineer/sites/aiecode2025/sha256/c25a8abc1b72dda0100faa283bab2bb75d59a4d7cb5bf513d9344fb27e045fa4.webp)

Last login: Fri Jun 26 20:00:37 on ttys000
~/froglet-demo

Interface text:
~/froglet-demo
at 20:02:22

### Trial preflight

The preflight response lists the trial’s allowed host and paths, limits the hosted proof to demo.* services, and specifies the headers, HTTPS operations and polling the client needs.

[11:21](https://www.youtube.com/watch?v=Fu45geO3zX8&t=681s) [Terminal output lists the trial's authorized scope and begins a section on required client capabilities.](https://assets.ai.engineer/sites/aiecode2025/sha256/69c6f07e8cf6757c0d37ac967163dccc6ff394d6d5929de860f3cd10b22b9291.webp)

curl -sS https://try.froglet.dev/api/preflight \
  | jq '{authorized_scope, required_client_capabilities}'
{
  "authorized_scope": {
    "hosts": [
      "try.froglet.dev"
    ],
    "methods": [
      "GET",
      "POST"
    ],
    "paths": [
      "/llms.txt",
      "/.well-known/mcp.json",
      "/api/preflight",
      "/api/sessions",
      "/api/sessions/validate",
      "/v1/provider/services",
      "/v1/provider/services/{service_id}",
      "/v1/runtime/deals",
      "/v1/runtime/deals/{deal_id}",
      "/v1/feed"
    ],
    "rules": [
      "Only call the public hosted trial host and paths listed here.",
      "Do not scan, fuzz, enumerate unrelated paths, attack third-party hosts, or use [illegible]upplied URLs unless the user owns or controls them.",
      "Only demo.* services are part of the public hosted proof."
    ]
  },
  "required_client_capabilities": {

Interface text:
~/froglet-demo
Last login: Fri Jun 26 20:00:37 on ttys000

[11:24](https://www.youtube.com/watch?v=Fu45geO3zX8&t=684s) [Terminal showing allowed API paths, usage rules, and required client capabilities.](https://assets.ai.engineer/sites/aiecode2025/sha256/7814a5e4fd52f25228c47913a828eaf1742cf46a968fa497e72424ceb5ebc577.webp)

    ],
    "paths": [
      "/llms.txt",
      "/.well-known/mcp.json",
      "/api/preflight",
      "/api/sessions",
      "/api/sessions/validate",
      "/v1/provider/services",
      "/v1/provider/services/{service_id}",
      "/v1/runtime/deals",
      "/v1/runtime/deals/{deal_id}",
      "/v1/feed"
    ],
    "rules": [
      "Only call the public hosted trial host and paths listed here.",
      "Do not scan, fuzz, enumerate unrelated paths, attack third-party hosts, or use arbitrary user-supplied URLs unless the user owns or controls them.",
      "Only demo.* services are part of the public hosted proof."
    ]
  },
  "required_client_capabilities": {
    "custom_headers": [
      "Authorization: Bearer <session-token>",
      "content-type: application/json"
    ],
    "https_get": true,
    "https_post_json": true,
    "polling": true
  }
}

Interface text:
~/froglet-demo
at 20:03:20

### Froglet hosted trial execution

The presenter creates a 15-minute session token, then posts a demo.add execution payload with inputs 7 and 5 to Froglet’s hosted trial.

[11:34](https://www.youtube.com/watch?v=Fu45geO3zX8&t=694s) [Terminal showing a command to create a session beneath the preflight output.](https://assets.ai.engineer/sites/aiecode2025/sha256/362cab3cd760ed1c273bcca877120f133109228bded08bda2967911d1e59dc20.webp)

"/llms.txt",
"/.well-known/mcp.json",
"/api/preflight",
"/api/sessions",
"/api/sessions/validate",
"/v1/provider/services",
"/v1/provider/services/{service_id}",
"/v1/runtime/deals",
"/v1/runtime/deals/{deal_id}",
"/v1/feed"
],
"rules": [
  "Only call the public hosted trial host and paths listed here.",
  "Do not scan, fuzz, enumerate unrelated paths, attack third-party hosts, or use arbitrary user-supplied URLs unless the user owns or controls them.",
  "Only demo.* services are part of the public hosted proof."
]
},
"required_client_capabilities": {
  "custom_headers": [
    "Authorization: Bearer <session-token>",
    "content-type: application/json"
  ],
  "https_get": true,
  "https_post_json": true,
  "polling": true
}
}

TOKEN=$(curl -sS -X POST https://try.froglet.dev/api/sessions \
  | jq -r .session_token)
echo $TOKEN

Interface text:
~/froglet-demo
at 20:03:33

[12:52](https://www.youtube.com/watch?v=Fu45geO3zX8&t=772s) [Terminal showing an addition-service payload and a command to create an execution deal.](https://assets.ai.engineer/sites/aiecode2025/sha256/c22f9d504b86598ca5827b324379e98bcc9e97ed8fa63a0878f0bc475ba4814f.webp)

echo "$PROVIDER_ID"
d058d4e324107466f29967b08e6cbcbc8d3b1f35a13a8edfc6d5e11250ade570
PAYLOAD=$(jq -nc --arg provider_id "$PROVIDER_ID" '{
  provider: {
    provider_id: $provider_id,
    provider_url: "https://ai.froglet.dev"
  },
  offer_id: "demo.add",
  kind: "execution",
  execution: {
    schema_version: "froglet/v1",
    workload_kind: "demo.add",
    runtime: "builtin",
    package_kind: "builtin",
    entrypoint: { kind: "builtin", value: "demo.add" },
    contract_version: "froglet.builtin.demo.add.v1",
    input_format: "application/json+jcs",
    input_hash: "728a671a0a05e573bb0c3e37688fc3302d913187cb274f2e0b2940e1c2e4b719",
    requested_access: [],
    security: { mode: "standard" },
    mounts: [],
    input: { a: 7, b: 5 },
    builtin_name: "demo.add"
  }
}')
CREATE=$(curl -sS -H "Authorization: Bearer $TOKEN" \
  -H 'content-type: application/json' \
  -X POST https://try.froglet.dev/v1/runtime/deals \
  --data "$PAYLOAD")

Interface text:
~/froglet-demo
at 20:04:51

### Execution result

The demo polls the deal until it succeeds. Adding 7 and 5 returns 12, and the result reports that a receipt is present.

[13:13](https://www.youtube.com/watch?v=Fu45geO3zX8&t=793s) [Terminal polling a deal and showing a successful result of 12 with a receipt.](https://assets.ai.engineer/sites/aiecode2025/sha256/8cfa786b6200138340220239724c36df71c03128be3de0c657ea8869d7eec90c.webp)

    security: { mode: "standard" },
    mounts: [],
    input: { a: 7, b: 5 },
    builtin_name: "demo.add"
  }
}')
❯ CREATE=$(curl -sS -H "Authorization: Bearer $TOKEN" \
  -H 'content-type: application/json' \
  -X POST https://try.froglet.dev/v1/runtime/deals \
  --data "$PAYLOAD")
❯ DEAL_ID=$(printf '%s\n' "$CREATE" | jq -r '.deal.deal_id')
echo "$DEAL_ID"
3987201fc7f8556afa1324c2b1cf6660
❯ for _ in 1 2 3 4 5; do
  RESULT=$(curl -sS -H "Authorization: Bearer $TOKEN" \
    "https://try.froglet.dev/v1/runtime/deals/$DEAL_ID")
  STATUS=$(printf '%s\n' "$RESULT" | jq -r '.deal.status')
  [ "$STATUS" = "succeeded" ] && break
  sleep 1
done

printf '%s\n' "$RESULT" \
  | jq '{status: .deal.status, result: .deal.result, has_receipt: (.deal.receipt != nu[illegible]
{
  "status": "succeeded",
  "result": {
    "sum": 12
  },
  "has_receipt": true
}

Interface text:
clear
~/froglet-demo
at 20:05:12

### Froglet health checks

The demo checks the provider and runtime on separate local ports. Both health endpoints return an ok status.

[14:16](https://www.youtube.com/watch?v=Fu45geO3zX8&t=856s) [Terminal shows successful health responses from the provider and runtime.](https://assets.ai.engineer/sites/aiecode2025/sha256/ecdadd32a4c6a27f5dd1ee8896da2a71fbd01260123c2796d7e64604175a2999.webp)

✓ Container froglet_agent-provider-1 Healthy 0.5s
✓ Container froglet_agent-runtime-1 Running 0.0s
{
  "status": "ok",
  "bootstrap_dir": "/Users/armanas/.froglet/agent",
  "data_dir": "/Users/armanas/.froglet/data",
  "froglet_node": "/Users/armanas/.local/bin/froglet-node",
  "provider_url": "http://127.0.0.1:8080",
  "runtime_url": "http://127.0.0.1:8081",
  "network_mode": "clearnet",
  "compose_file": "/Users/armanas/.froglet/agent/compose.yaml",
  "compose_project_name": "froglet_agent",
  "compose_started": true,
  "agent_target": "claude-code",
  "mcp_docker_network": "froglet_agent_default",
  "mcp_config_path": "/Users/armanas/.froglet/agent/mcp/.mcp.json",
  "next_mcp_actions": ["status", "publish_artifact"],
  "next_instruction": "Restart or point your agent at the MCP config path, call froglet status, then publish a demo service with template demo.add."
}

curl -sS http://127.0.0.1:8080/health | jq .
curl -sS http://127.0.0.1:8081/health | jq .
{
  "service": "froglet",
  "status": "ok"
}
{
  "service": "froglet",
  "status": "ok"
}

Interface text:
~/froglet-demo
at 20:06:15

### Matching node identities

The provider and runtime return the same node ID. The speaker explains that one Froglet can take multiple roles, including provider and consumer.

[14:28](https://www.youtube.com/watch?v=Fu45geO3zX8&t=868s) [Terminal shows provider and runtime returning the same node identifier.](https://assets.ai.engineer/sites/aiecode2025/sha256/978e303f4d9116ed09203eecde468aa467bc3f0cd9c2e791efeb5c488acf3606.webp)

"bootstrap_dir": "/Users/armanas/.froglet/agent",
"data_dir": "/Users/armanas/.froglet/data",
"froglet_node": "/Users/armanas/.local/bin/froglet-node",
"provider_url": "http://127.0.0.1:8080",
"runtime_url": "http://127.0.0.1:8081",
"network_mode": "clearnet",
"compose_file": "/Users/armanas/.froglet/agent/compose.yaml",
"compose_project_name": "froglet_agent",
"compose_started": true,
"agent_target": "claude-code",
"mcp_docker_network": "froglet_agent_default",
"mcp_config_path": "/Users/armanas/.froglet/agent/mcp/.mcp.json",
"next_mcp_actions": ["status", "publish_artifact"],
"next_instruction": "Restart or point your agent at the MCP config path, call froglet status, then publish a demo service with template demo.add."
}

❯ curl -sS http://127.0.0.1:8080/health | jq .
curl -sS http://127.0.0.1:8081/health | jq .
{
  "service": "froglet",
  "status": "ok"
}
{
  "service": "froglet",
  "status": "ok"
}

❯ curl -sS http://127.0.0.1:8080/v1/node/identity | jq -r .node_id
curl -sS http://127.0.0.1:8081/v1/node/identity | jq -r .node_id
ad8eb479233ad838d20cc50eabc33f486108f56cdb4d0e4b5c3289ccfc3b874d
ad8eb479233ad838d20cc50eabc33f486108f56cdb4d0e4b5c3289ccfc3b874d

Interface text:
~/froglet-demo
at 20:06:26

### Opening MCP management

The presenter enters /mcp in Claude Code to check whether the Froglet MCP server is enabled.

[15:01](https://www.youtube.com/watch?v=Fu45geO3zX8&t=901s) [Claude Code shows the MCP management command at its prompt.](https://assets.ai.engineer/sites/aiecode2025/sha256/f3377ecfb1146baae2f75f24a55e18789c0512ed875dd4a194e128a3f2efe8b2.webp)

Claude Code v2.1.193

Welcome back ap!
Opus 4.8 (1M context) · Claude Team · Alithea-bio
~/froglet-demo

Tips for getting started
Ask Claude to create a new app or clone a re...

What's new
Added `autoMode.classifyAllShell` setting to...
Added auto-mode denial reasons to the transc...
Added `claude_code.assistant_response` OpenT...
/release-notes for more

/mcp  Manage MCP servers
/claude-api  Reference for the Claude API / Anthropic SDK — model params, streaming, tool use, MCP, agents, caching, to[illegible]
/fewer-permission-prompts  Scan your transcripts for common read-only Bash and M[illegible] then add a prioritized allowlist to project .claude/se[illegible]

> /mcp

Interface text:
~/froglet-demo — ☀ Claude Code — node ‹ claude
armanas@Armanass-MacBook-Air:froglet-demo [Opus 4.8 (1M context)] 20:07:02
»» don't ask on (shift+tab to cycle)

## Full transcript

[0:01](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1s) Hello, everybody. I'm Armanas. I work at Alithea Bio where we focus on life sciences topics. More specifically, we work on immuno-oncology and immunopeptidomics.

[0:13](https://www.youtube.com/watch?v=Fu45geO3zX8&t=13s) While we work on science topics, we use ourselves and provide to our clients, uh, agentic automation or agentic AI solutions.

[0:24](https://www.youtube.com/watch?v=Fu45geO3zX8&t=24s) However, we found a certain gap which we would like to discuss today, and we have a solution which we're working on, which we would like to share. It's called Froglet.

[0:37](https://www.youtube.com/watch?v=Fu45geO3zX8&t=37s) But to start with, I would like to ask, what do you think is most valuable work that agentic automation can do?

[0:50](https://www.youtube.com/watch?v=Fu45geO3zX8&t=50s) My guess, uh, scientific research automation would be quite high up that list.

[0:56](https://www.youtube.com/watch?v=Fu45geO3zX8&t=56s) However, from my experience, adding more tools to agents will not suffice.

[1:03](https://www.youtube.com/watch?v=Fu45geO3zX8&t=63s) Because science, and especially lives-- and especially in life sciences, is, uh, inherently collaborative process.

[1:14](https://www.youtube.com/watch?v=Fu45geO3zX8&t=74s) And in order to enable agents to collaborate, we need a way to have a verifiable chain of receipts. What do I mean? We need a solution which can provide these receipts, proving every step, ensuring that every result can be trusted, and enabling repeatability as well as collaboration at scale.

[1:41](https://www.youtube.com/watch?v=Fu45geO3zX8&t=101s) Having this thesis in mind, let's go to the next step. So

[1:47](https://www.youtube.com/watch?v=Fu45geO3zX8&t=107s) stepping back, um, we imagine agents as cooks in the kitchen.

[1:54](https://www.youtube.com/watch?v=Fu45geO3zX8&t=114s) Giving them more tools or better tools, uh, improves kitchen's efficiency.

[2:03](https://www.youtube.com/watch?v=Fu45geO3zX8&t=123s) Better knives, more pans, more ovens definitely boost the speed and quality,

[2:10](https://www.youtube.com/watch?v=Fu45geO3zX8&t=130s) but it only enhances the local work. On another hand, scientific work is not cooking alone in your own kitchen.

[2:21](https://www.youtube.com/watch?v=Fu45geO3zX8&t=141s) It is closer to running a Michelin star restaurant.

[2:26](https://www.youtube.com/watch?v=Fu45geO3zX8&t=146s) To overcome this, uh, to, to-- The outcome depends on providers and quality of their produce,

[2:36](https://www.youtube.com/watch?v=Fu45geO3zX8&t=156s) high-level services, as well as an, an ability to consistently deliver the same quality dish again and again and again.

[2:46](https://www.youtube.com/watch?v=Fu45geO3zX8&t=166s) You cannot bring everything into one kitchen. The challenge isn't local. It's not local tools. The challenge is aligning the entire supply chain that it's repeatable and consistent.

[3:02](https://www.youtube.com/watch?v=Fu45geO3zX8&t=182s) Today, we have already agents with plenty of tools and increasing in volume, number, and quality. And we also have on another hand data, uh, and specialized analytics algorithms and compute which are distributed ac-across different organizations

[3:23](https://www.youtube.com/watch?v=Fu45geO3zX8&t=203s) and siloed. So our vision is that whenever AI agent workflow automation matures, organizations will give to the agents not only tools, they will give them budgets.

[3:43](https://www.youtube.com/watch?v=Fu45geO3zX8&t=223s) We're already kind of doing this in a primitive form by pr-- allocating tokens for-- token budgets for a specific task. But what I'm talking is a bit broader. It's allowing agents to manage their own budgets to achieve their own goals, whether it's to discover services, request data, negotiate execution terms, or

[4:08](https://www.youtube.com/watch?v=Fu45geO3zX8&t=248s) pay for work, uh, across organizational boundaries. At that point, an agent is no longer just a cook with a better knife. It starts to act like a chef,

[4:24](https://www.youtube.com/watch?v=Fu45geO3zX8&t=264s) uh, like a executive chef, uh, finding suppliers, ordering ingredients, coordinating work at, at the kitchen, and finally keeping the record of what has happened.

[4:38](https://www.youtube.com/watch?v=Fu45geO3zX8&t=278s) That is why we are building Froglet, an open source protocol for agents to discover, transact with, and receive verifiable receipt

[4:49](https://www.youtube.com/watch?v=Fu45geO3zX8&t=289s) from external datas-- uh, data and service providers.

[4:56](https://www.youtube.com/watch?v=Fu45geO3zX8&t=296s) For more detailed information, obviously go to our page, froglet.dev, uh, where you will find, um, general descriptions on how it works, what it integrates with. It-- Froglet is designed to be in between the moving parts.

[5:14](https://www.youtube.com/watch?v=Fu45geO3zX8&t=314s) It's not designed to replace. It's designed to integrate. It integrates with different payment rails. It integrates with different agent harnesses, execution environments, and even transport protocols.

[5:27](https://www.youtube.com/watch?v=Fu45geO3zX8&t=327s) And it doesn't require that every node in the network uses the same software stack. That's the beauty. We are not forcing everyone to use the same-- uh, to, to work the same way.

[5:38](https://www.youtube.com/watch?v=Fu45geO3zX8&t=338s) We're just asking everybody to use the same interface.

[5:44](https://www.youtube.com/watch?v=Fu45geO3zX8&t=344s) In the webpage, you will find how to run Froglet, uh, with just-- how to install it locally just with one command, or even how to run it remotely just with one prompt.

[6:00](https://www.youtube.com/watch?v=Fu45geO3zX8&t=360s) So in essence, um, what we're saying is closed source scientific collaboration often turns into a bespoke project, enterprise project that can take years and cost millions before any reusable workflow exists.

[6:18](https://www.youtube.com/watch?v=Fu45geO3zX8&t=378s) On the other hand, Froglet's mission is to make transaction layer much lighter.

[6:24](https://www.youtube.com/watch?v=Fu45geO3zX8&t=384s) Once an organization decides that the, mm, data or resource or service is deemed shareable,

[6:35](https://www.youtube.com/watch?v=Fu45geO3zX8&t=395s) uh, and it's exposed in Froglet, an agent can discover it, understand the terms, request the work, and re-receive a verifiable, uh, receipt.

[6:46](https://www.youtube.com/watch?v=Fu45geO3zX8&t=406s) That setup costs a few thousand tokens and takes minutes.

[6:55](https://www.youtube.com/watch?v=Fu45geO3zX8&t=415s) Now, if I may, uh, let me open our website for a quick second.

[7:03](https://www.youtube.com/watch?v=Fu45geO3zX8&t=423s) So if you land our... Uh, if you go and land our, uh, homepage, uh, you will see, uh, a couple of things. First, a lot of helper information which allows, uh, you or your agent to read through and understand how it works.

[7:18](https://www.youtube.com/watch?v=Fu45geO3zX8&t=438s) And most of our webpage is focused on, uh, agent use. But also we have some helpful documentation for you. Let me go through a couple of steps in the demo.

[7:32](https://www.youtube.com/watch?v=Fu45geO3zX8&t=452s) So first of all, we find that a Froglet node by itself is not different implementations at each site. It is actually exactly the same node. It just plays different roles, whether it's a provider, requester, or marketplace.

[7:50](https://www.youtube.com/watch?v=Fu45geO3zX8&t=470s) Marketplace itself is just a Froglet node which is reque-- uh, providing certain services.

[7:59](https://www.youtube.com/watch?v=Fu45geO3zX8&t=479s) And what does it help to do? It, it helps to find, to trust, to pay, and to prove that work has happened.

[8:09](https://www.youtube.com/watch?v=Fu45geO3zX8&t=489s) That is it. We're not trying to replace any core functionalities of other tools or protocols.

[8:18](https://www.youtube.com/watch?v=Fu45geO3zX8&t=498s) Whenever you are generating a or creating a new node, it generates a key pair for identity and signing the artifacts.

[8:27](https://www.youtube.com/watch?v=Fu45geO3zX8&t=507s) And during the execution, everything is being signed with that signature, meaning everything is being signed in a chain, and the chain is only valid if, uh, all data points are not tampered with.

[8:45](https://www.youtube.com/watch?v=Fu45geO3zX8&t=525s) And in, in terms of discovery request, uh, providers are publishing what services they, uh, they, uh, they are providing to, to the marketplace using the same protocol. And requester requests a known marketplace just to provide lists of services that are available on that marketplace.

[9:08](https://www.youtube.com/watch?v=Fu45geO3zX8&t=548s) From there-- that moment on, once the requester identifies the service that they want to work with, their communication is direct. There is no, uh, third party. And everything from quote to deal to execution and receipt happens in one interaction.

[9:31](https://www.youtube.com/watch?v=Fu45geO3zX8&t=571s) Let me jump forward a bit. So, so far what I showed you is just a node talking to a node. Where agent comes in, uh, are the plugins that we placed inside the Froglet core.

[9:47](https://www.youtube.com/watch?v=Fu45geO3zX8&t=587s) It integrates with different execution environments and different harnesses, whether it's OpenClaw, NemoClaw, it's, uh, acts as m-MCP server or plugin, and it's primarily designed that it is used by an, an agent.

[10:08](https://www.youtube.com/watch?v=Fu45geO3zX8&t=608s) The primary interface for humans should be an LLM. An LLM should drive usage of Froglet, whether you are a provider or a requester.

[10:24](https://www.youtube.com/watch?v=Fu45geO3zX8&t=624s) So now maybe let's jump to a terminal, and I will show you a couple of things.

[10:44](https://www.youtube.com/watch?v=Fu45geO3zX8&t=644s) First of all, I will show you how to, uh, how you can use, uh, Froglet remotely, meaning that there is a Froglet node, uh, running in a remote server where you can access and get a fifteen minutes, um, trial, uh, identity which you can play with.

[10:59](https://www.youtube.com/watch?v=Fu45geO3zX8&t=659s) Second, how to run a Froglet locally on my machine here on Docker. And third, uh, how I will ask my Claude to interact with local installation and actually configure a service and try it out.

[11:15](https://www.youtube.com/watch?v=Fu45geO3zX8&t=675s) So first of all, what we-- or what I would like to do is to run a command to check whether Froglet, uh, try.froglet.dev actually exists, and it works. That's fine.

[11:29](https://www.youtube.com/watch?v=Fu45geO3zX8&t=689s) So now what I can do is to create myself a token,

[11:35](https://www.youtube.com/watch?v=Fu45geO3zX8&t=695s) and this, uh, this creates a temporary token for fifteen minutes. Uh, and you can see it here created.

[11:47](https://www.youtube.com/watch?v=Fu45geO3zX8&t=707s) And then what I can do also in exactly same manner, I can have access to the specific, um, provider token, and this is a specific provider, uh, which adds two numbers.

[12:01](https://www.youtube.com/watch?v=Fu45geO3zX8&t=721s) It's very simple example, uh, service provider. As you see that, uh, the tokens are different. That means the, the Froglet nodes are different.

[12:12](https://www.youtube.com/watch?v=Fu45geO3zX8&t=732s) Now in order to execute, uh, this, uh, service, uh, what I need, I need to create a payload.

[12:22](https://www.youtube.com/watch?v=Fu45geO3zX8&t=742s) So I create a payload which includes, um, many things, including schema, what kind of, uh, service I'm targeting, also, uh, which provider, and finally, uh, what input I'm providing it, uh, to.

[12:37](https://www.youtube.com/watch?v=Fu45geO3zX8&t=757s) So I'm providing it, um, seven and five. Seven plus five.

[12:44](https://www.youtube.com/watch?v=Fu45geO3zX8&t=764s) Now what I need is to pro-provide this payload to my remote, um, r-remote Froglet.

[12:54](https://www.youtube.com/watch?v=Fu45geO3zX8&t=774s) And as this executes, I need to get a deal ID and this is where I have a receipt of actually deal happening. Now deal, uh, has an ID already, but, uh, it might have happened that it takes some time to slow execute, so I take a for command-- for loop to actually, uh, wait for it.

[13:17](https://www.youtube.com/watch?v=Fu45geO3zX8&t=797s) But it depends on the load on that temporary small node that, uh, that runs on, on the cloud. And here we have an answer. It's 12. Fantastic. We have a correct answer.

[13:30](https://www.youtube.com/watch?v=Fu45geO3zX8&t=810s) Um, so we have a entire loop, uh, finalized. Now, in order to run it locally,

[13:38](https://www.youtube.com/watch?v=Fu45geO3zX8&t=818s) um, what I need is to install it here. So first of all,

[13:44](https://www.youtube.com/watch?v=Fu45geO3zX8&t=824s) I will clear everything. As you see, the, uh, the re... uh, the directory is empty and what I do is I-- what I run is HTTPS froglet.dev agent, and what it will do, it will download and install agent on a Docker.

[14:04](https://www.youtube.com/watch?v=Fu45geO3zX8&t=844s) Let's wait a second. It's actually already there, so it just confirms that it doesn't need to download anything and it's working and it's running.

[14:15](https://www.youtube.com/watch?v=Fu45geO3zX8&t=855s) And now I can see that, uh, there are two Froglets running. Um, but if I look at,

[14:24](https://www.youtube.com/watch?v=Fu45geO3zX8&t=864s) at the actually not IP addresses and ports, but I actually look at the node ID, I see that this is one and the same ID. And that means that each, each Froglet can assume different roles and the same time can assume multiple roles.

[14:40](https://www.youtube.com/watch?v=Fu45geO3zX8&t=880s) And we have here two roles as a provider and consumer at the same time. And just to prove that I'm running it on a Docker, uh, here it is running on the same port, same IP address as my local ins-installations.

[14:57](https://www.youtube.com/watch?v=Fu45geO3zX8&t=897s) So now Claude. If I open my Claude, first of all, what I need to do, uh, is to see whether Froglet MCP is enabled, and it is. That's fantastic.

[15:13](https://www.youtube.com/watch?v=Fu45geO3zX8&t=913s) And what I will ask it to do is, first of all, I will change the permissions that it doesn't bug me.

[15:24](https://www.youtube.com/watch?v=Fu45geO3zX8&t=924s) And what I will ask it is, uh, use Frog-Froglet

[15:32](https://www.youtube.com/watch?v=Fu45geO3zX8&t=932s) MCP only. Do not install anything. And, um,

[15:44](https://www.youtube.com/watch?v=Fu45geO3zX8&t=944s) just let's be very specific. And let's see if it understands the constraints.

[15:52](https://www.youtube.com/watch?v=Fu45geO3zX8&t=952s) And I have here prepared a couple of steps. Um, I won't do it-- them one by one.

[16:00](https://www.youtube.com/watch?v=Fu45geO3zX8&t=960s) I'll actually ask you to do it all at once

[16:07](https://www.youtube.com/watch?v=Fu45geO3zX8&t=967s) in steps and provide a specific output. Great. It even goes ahead and, um, uh, checks what is running.

[16:21](https://www.youtube.com/watch?v=Fu45geO3zX8&t=981s) And what I'm asking it to do is, first of all, to see whether the status is live, which already did above. Uh, then if provider and runtime is healthy, then I want it to publish an artifact from a template, which is exactly the same template, add two numbers.

[16:42](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1002s) Then, uh, what I want it, uh, that it actually finds and, uh, calls that service and invokes it locally, uh, asking it to add again five and seven.

[16:56](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1016s) And it can wait a bit because, uh, it's an asynchronous call. And then show the output on what it got.

[17:06](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1026s) So if, if we go, mm, if we go down here, here is what we see that it actually executes all commands.

[17:19](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1039s) And what we see that it's actually, um, done exactly as we asked. We-- it has a result, sum 12, and it, it can create anything that you want. It can, uh, connect to...

[17:33](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1053s) You can ask Claude to connect to your database and provide row by row access for, for, uh, for a payment, or you can have a just your GPU running in the background and, mm, welcome the request for computa- any kind of computation.

[17:51](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1071s) In essence, it's a very simple way how to use it, but it packages a lot of, um, underlying protocols and underlying tools, where now you're not shoving everything into a, a LLM context.

[18:06](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1086s) It just has a, a services that it needs to interact. And underneath there is a receipt, there is a payment, there is a execution environment, and there is a negotiation and marketplace hidden, and it's, uh, doesn't stuff your LLM with context.

[18:26](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1106s) So going back to the slides. Some reason it scrolled down.

[18:34](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1114s) Going back to the slides, um, so what we, what do we have on, uh, on our hands? Uh, we have an open protocol called Froglet, which, um, has multiple things.

[18:47](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1127s) First of all, uh, it, uh, provides a way, uh, to, to find resources outside the organizational boundaries. Then it allows your agents to actually execute, uh, remote, uh, commands.

[19:06](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1146s) And third, uh, what it allows, it allows to have a verifiable rec- chain of, uh, receipts of what has happened. And I think that actually enables a collaborative science.

[19:19](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1159s) That enables a progress of, uh, perpetual science automation.

[19:26](https://www.youtube.com/watch?v=Fu45geO3zX8&t=1166s) So please join us, uh, either via Froglet or Alithea Bio, and please join us on GitHub, and thank you for listening.
