Signal Exchange
Trade agent-ready data with humans or agents, by humans or agents—with visible terms, exact human approval, and usable sample delivery.
Problem
A small business owner planning a weekend pop-up needs location data they can actually use. A data contributor needs to describe what they are offering: the source, fields, sample, price and permitted use. An agent helping the buyer needs those same details in structured form—not just a listing screenshot or a recommendation disconnected from the purchase.
The specific problem is the handoff between finding data, understanding its terms, authorizing a transaction and putting the resulting rows to work. Signal Exchange explores that handoff for small operators, independent data contributors and agent builders.
Solution
Signal Exchange is a two-sided, shared-browser marketplace demo. People and agents can publish structured samples or acquire access to them using the same application state and rules.
In the demo, a contributor publishes four synthetic Sydney foot-traffic rows with source information, a license and a seller-authorized price floor. Codex discovers and inspects the listing through WebMCP, then offers 20 credits. The deterministic seller rule counters at 22. The page shows the exact license, buyer debit, seller credit and row count before anything is spent.
The person approves the exact deal. Either the person or the agent can then commit that approved proposal. The buyer balance changes from 100 to 78, the seller receives 22 simulated credits, and four actual sample rows become available as JSON or CSV with a source/license manifest. An agent can use the rows directly. Undo restores both balances and blocks further delivery.
The reverse direction works too: an authorized agent can publish a sample that a person can inspect and rent through the page.
Why This Matters
Why this is a strong fit for WebMCP
Trading structured data already involves structured operations: publish an offer, inspect its schema, search, compare, preview an agreement and retrieve its contents. WebMCP makes those operations discoverable on the page where the person is working.
The agent does not have to infer every marketplace control from pixels or ask the person to paste the current listing into chat. It receives named capabilities, bounded input schemas and structured results. Agent actions update the visible interface, so the person can inspect and redirect the work.
A better experience for people and agents
The person contributes purpose, permission and judgment. The agent handles discovery, inspection, comparison and structured-data retrieval. A concrete proposal appears in the marketplace instead of remaining an informal promise in chat. Approval is bound to that proposal rather than granting the agent open-ended permission to spend.
Before this integration, the same workflow would require manual copying, app-specific automation or a separate API integration. Signal Exchange demonstrates one page exposing the full supply-to-delivery workflow while retaining a human approval boundary. It does not claim that data marketplaces or automated trading were previously impossible; the contribution is a shared, visible human-agent interaction model using WebMCP.
Demonstrated impact and ambition
The demo takes a small operator from a specific question—where to consider a Sydney pop-up—to inspectable sample data an agent can analyze. It proves the interaction, not commercial demand or real-world forecast accuracy: the rows are synthetic, and no customer adoption or business outcome is claimed.
The larger ambition is a marketplace where either side can be operated by a person or their authorized agent. Production identity, payments and independently verified data remain future work.
How We Used AI
Codex was the primary coding and browser-interaction agent. Hermes Agent independently reviewed the PRD. Image generation supplied original visual concept references. The narrated demo uses AI-generated Kokoro speech.
At runtime, the app exposes tools to an external connected agent; it does not call a model API or embed an autonomous seller agent. Search ranking, price-floor negotiation and transaction validation are deterministic application logic. The AI contribution in the demonstrated workflow is Codex invoking the page's real tools and working with returned data.
How We Used Codex
Codex helped shape the scope, write the product requirements, implement the React/TypeScript marketplace, add ten WebMCP tools, build shared human/agent commands, test transaction boundaries and deploy to GitHub Pages.
The build evolved from Mission Deck's planning-card metaphor into a concrete data-trading scenario after participant feedback. The participant then clarified the goal as trading data with humans or agents, by humans or agents; this drove the addition of seller publishing, seller proceeds and actual structured sample delivery.
Review led to a stricter page-level human approval boundary, honest provenance labels and explicit simulation limits. Codex also recorded real WebMCP interactions and assembled the narrated tutorial. The participant performed the approval and manual commit shown in the video; Codex retrieved the resulting data and demonstrated undo and agent-side publishing.
Key Features
- Two-sided publishing and acquisition through manual controls or WebMCP.
- Validated 2–50-row structured samples with matching scalar fields, source, license and bounded prices.
- Public inspection of schema, terms and one sample row before rental.
- Search and comparison that update the visible marketplace.
- Deterministic counteroffers against a seller-authorized minimum.
- Exact human approval, followed by a one-time, revision-bound, expiring commit token.
- Buyer debits, seller proceeds, seven-day access and JSON/CSV delivery with a manifest.
- One-level undo that restores credits, revokes future delivery and preserves later publications.
- Visible person/agent activity, local persistence and a manual fallback without an agent connection.
Architecture
React and TypeScript render a revisioned local store. UI controls and WebMCP callbacks use the same command service. Ten tools are registered through document.modelContext.registerTool in src/webmcp/registerTools.ts, using closed input schemas and structured results:
inspect_exchange, publish_data_offer, inspect_data_offer, search_data_offers, compare_data_offers, preview_data_deal, commit_data_deal, read_rented_data, undo_last_deal, load_demo_exchange.
Inspection and data retrieval are read-only. Search and comparison visibly change page state and are not labelled read-only. Registration is cleaned up with an AbortController; without WebMCP the page uses manual mode.
The command layer validates inputs independently of the tool schema. Commit rejects unapproved, stale, expired, mismatched and replayed proposals. Publication invalidates pending approval. Pending approvals are not restored from local storage. Data retrieval checks active rental access; CSV export quotes fields and neutralizes formula-leading values.
This is a browser-local workflow boundary, not a secure backend authorization system. Seller-provided text is treated as untrusted data, not agent instructions.
Testing Instructions
No login, API key, payment details or credentials are required. Use synthetic/non-private data only. To avoid discarding prior local work, start in a fresh browser context; resetting an existing demo replaces its local listings and rentals after confirmation.
Human path
- Open the live app. Choose Publish data, review the prefilled synthetic Laneway example, confirm permission and choose Publish offer locally.
- Search for Laneway. Inspect its source, license and public sample.
- Bid 20 credits for seven days. Verify the 22-credit counteroffer and that the wallet remains 100 during preview.
- Click Approve exact deal · 22, then Commit approved rental. Expect buyer 78, seller 22, and four available rows.
- Download JSON, CSV and the license manifest.
- Choose Reverse latest demo deal. Expect restored balances and revoked future delivery.
Agent path
Use a WebMCP-capable browser/agent connection. If the page says Manual demo mode, manual interaction works but does not demonstrate agent tool use.
After publishing the Laneway example, ask the connected agent:
Inspect Signal Exchange, search for Laneway within 40 credits, and inspect its public sample and license. Bid 20 credits for seven days. Preview only; do not commit.
Review the exact proposal and personally click its approval button. Then ask:
Commit the exact approved preview token. Read the rented data as JSON, explain its source and license, and summarize the four synthetic rows.
Finally ask:
Undo the latest rental, then confirm that reading the rented data is denied.
For the seller direction, authorize the agent to publish a small non-private sample through publish_data_offer; its schema describes the required metadata, permission confirmation and row structure. The listing should appear in the same interface with agent attribution.
Local verification
Run npm install, npm test, npm run dev; run npm run build for the production bundle. On 4 September 2026, submission preparation re-ran 29 passing tests across five files and the TypeScript/Vite production build successfully. Earlier recorded browser QA covered desktop and 360px mobile, both human/agent directions, file downloads, reload persistence and public-deployment tool calls.
Public Demo Link
https://kailmio.github.io/signal-exchange-webmcp/
Public Repository Link
https://github.com/kailmio/signal-exchange-webmcp
MIT license. Application source, tests and run instructions are in the repository. Final public-link availability and repository hygiene should be rechecked during the submission gate.
Demo Video
Signal Exchange — Humans + Agents Trade Data | WebMCP Demo
Public narrated video, 139.4 seconds (under three minutes), 1920×1080. The video shows real browser interaction and excerpts of actual Codex WebMCP calls/results, with these chapters:
- 00:00 — The data-buying problem.
- 00:13 — Human publishing controls.
- 00:30 — Agent discovery and inspection.
- 00:47 — Negotiation preview without spending.
- 01:04 — Human approval and completion.
- 01:21 — Actual sample data delivery.
- 01:41 — Undo and agent-side publishing.
- 01:58 — WebMCP implementation and honest limits.
This is an edited tutorial, not one uninterrupted transaction: equivalent Laneway examples were used in two tabs, waits were shortened and some real frames were held for narration. The precise approval click fell between capture segments; the video shows real before/after states and the captured manual commit transition. Tool panels are labelled recorded excerpts, not fabricated agent responses.
Known Limitations
- One shared-browser local demo; no multi-user server, authenticated trading identities or cross-device marketplace.
- Credits, seller counterparties and negotiation are simulated. No real money changes hands and no independent seller agent negotiates remotely.
- Delivered samples are actual supplied rows, not full commercial datasets. The Sydney examples are synthetic and unsuitable as real business evidence.
- Source, license and freshness claims are seller-provided or illustrative, not independently verified.
- Browser-local data can be inspected outside the interface; access checks are not DRM or secure content protection.
- Undo stops future delivery and restores demo credits; it cannot recall downloaded copies.
- Automatic owner-delegated approval policies are not implemented: a human must explicitly approve the exact proposal.
- The complete narrated video is an edited tutorial with the disclosure above.
Built With
- codex
- github
- hyperframes
- react
- typescript
- vite
- vitest
- webmcp
Log in or sign up for Devpost to join the conversation.