Francesco Marinoni Moretto
Lead AI Architect working on agent-native commerce. Creator of LAR, Stream Coding & Clarity Gate; author of Selling to Agents.
Milan, Italy
Actions
Francesco Marinoni Moretto works on agent-native commerce, how merchants and publishers make their catalogs and content legible to AI purchasing agents.
He is the author of the Layered Agentic Retrieval (LAR) working paper and the forthcoming book "Selling to Agents: The Merchant Playbook for Agentic Commerce".
His current focus is the publisher-side surfaces -and the payment rails (UCP/ACP, HTTP Message Signatures)- that sit in front of MCP and APIs. He also builds open tooling for probing and serving agent-consumable commerce endpoints (like ucp-probe and the LAR spec).
He also created two open-source frameworks on AI reliability, Stream Coding, a documentation-first methodology for AI-accelerated development (stream-coding.com), and Clarity Gate, a pre-ingestion verification protocol for RAG epistemic quality (github.com/frmoretto/clarity-gate), both from a single thesis: LLMs don't need help, they need clear and excellent documentation.
Based in Milan, he is AI Practice and Community Leader at N1AI, a 400+ member professional group.
Recently he moderated a roundtable hosted by GS1 Italy on agentic commerce and was the guest in a fireside chat at the ILTA Legal Tech On Tour in Milan. He presents regularly at Milan AI events including Claude Code Meetup, AI Tinkerers and Aperitivo AI.
Links
Area of Expertise
Topics
Reading is Free, Spending is Not: what a minimal agent learns probing live ecommerce endpoints
Most discussion of agentic commerce takes the platform's side. This talk takes the merchant's.
I built ucp-probe (a minimal, unaffiliated agent, a few dozen lines, no platform deal) and pointed it at Allbirds' live commerce endpoints (UCP/ACP) in May 2026.
The result is uncomfortable and clarifying.
Reading a store's published capabilities at /.well-known/ucp is anonymous and permissionless.
Querying the live catalog needs only self-identification, a small profile declaring the protocol version the agent speaks; one call returned a real product (Men's Wool Runner, $110, in stock) straight from the merchant's backend.
But moving money is gated: a cryptographically signed agent (HTTP Message Signatures, RFC 9421) plus a retry-safe idempotency key.
Reading is free; spending is not.
I'll run the probe live, then turn to what this means for anyone publishing a catalog: your data is already legible to any competent agent that asks, you can't gate the read, and you won't see most of it in analytics.
The probe is open source; attendees leave able to run it against their own endpoints and reason about the one layer that's actually gated — the transaction.
Give Agents a Front Door: a declared surface that routes to MCP and APIs
An agent arrives at a merchant or publisher cold. Today it has two bad options: scrape rendered HTML (lossy and inferred) or already know it runs an MCP server or API.
There's a missing layer between an agent arriving and calling your tool: a surface the publisher authors, that an agent reads first — cheaply, deterministically — and routes it onward.
This talk is about that layer, in three parts: discovery (a declared, well-known surface stating who you are and what you offer), facts (catalog as JSON, declared-not-inferred), and actions (hand-off to MCP tools and to signed APIs / UCP-ACP).
I call the pattern Layered Agentic Retrieval (LAR), but the talk is the layering, not the label.
MCP standardizes agent-to-tool once the tool is known; REST/UCP serves data once the endpoint is known; this layer is the upstream front door that makes both discoverable to an arriving agent — the door, not the rooms.
I'll ground it in a live probe of real endpoints, situate it against the declared-surface family (llms.txt, AGENTS.md), and show why plain text for agents is already revealed preference.
The pattern is open source; you leave with a layering for your own MCP servers and APIs.
Why Lazy Loops Are Killing Poor Ralph (And How To Save Him)
Your AI coding agent is stuck in a loop. Regenerate. Tweak prompt. Regenerate. You're burning tokens while the agent confidently produces wrong code.
The problem isn't your agent. It's your spec.
Everyone has spec-writing tools: Spec Kit, Kiro, Tessl, etc
Nobody verifies specs are execution-ready before handing them to AI. Lazy loops that kill your Ralph (and your wallet).
Spec Gate: a 13-item verification protocol between your spec tools and coding agents. Git-verified: 7 modules, 46 endpoints in 4h34m, zero defects at first generation after 5 weeks of strategy and docs.
Open source. Every claim verifiable.
From Confident Falsehoods to Honest Abstention: Pre-Ingestion Verification for RAG Pipelines
RAG systems inherit the epistemic quality of their source documents. If a document presents assumptions as facts or omits uncertainty markers, downstream LLMs will confidently reproduce these errors regardless of retrieval accuracy or prompt engineering.
This talk presents Clarity Gate, an open-source pre-ingestion verification protocol that checks documents for epistemic quality before they enter RAG knowledge bases. The protocol applies 9 verification points producing intermediate documents with inline uncertainty metadata.
We benchmarked them across 6 LLM models using a document with 39 deliberate epistemic traps. Top-tier models achieved 100% detection with or without annotations. Mid-tier models improved measurably: Gemini Flash 75%->100% (+25%), GPT-5 Mini 81%->100% (+19%).
Honest confound: system prompt instructions alone achieved similar results on failing models. However, annotations persist across sessions, work without downstream prompt control, and scale across users.
Live on GitHub with unified .cgd.md specification. Relevant to anyone building RAG pipelines needing auditability, epistemic traceability, or EU AI Act compliance.
github.com/frmoretto/clarity-gate
Specification-Driven Development: treating AI as a production compiler
In AI-assisted development, documentation isn't overhead: it's the primary artifact. Code becomes compiled output from complete specifications.
This talk demonstrates how complete, unambiguous specifications dramatically reduce debugging time, validated through two independent systems:
Backend Case Study (5Levels):
- 7 intelligence modules implemented in 1.5-day execution phase
- 48 API endpoints, production-ready first deployment
- 5 weeks upfront: strategic thinking + documentation (4+1 weeks)
- Each module: 30 minutes average from spec to tested code
Frontend Case Study (Preflight Check - 8-hour hackathon):
- Complete React app generated in 3 minutes
- 59 UI components, 100+ files, deployed same day
- 2.5 hours compressed planning phase
You'll learn: Document Type Architecture (Structure + Purpose + Anti-patterns), the Clarity Gate verification process, why 75% complete specs produce 75% working code, and how quality gates catch issues early in the development cycle.
The 45-Second Death Spiral: How Connected AI Agents Can Ruin Real Lives
A single command like "terminate this customer" can ruin real lives within 45 seconds. This isn't theoretical: powerful Agent-to-Agent (A2A) and Model Context Protocol (MCP) interactions may trigger catastrophic cascades. Imagine: credit cards frozen, job applications blocked, insurance denied, financial blacklisting. Worse, recent Claude Opus 4 blackmail behavior (84% success rate) proves AI agents scheme beyond expectations. Learn robust safeguards using Constitutional AI and RLHF, with real-time demonstration illustrating ambiguity detection and verification loops. Based on enterprise AI deployment failures, I'll share actionable strategies to prevent unintended AI harm before regulators step in - and before it's too late.
https://www.linkedin.com/pulse/please-dont-terminate-your-customers-francesco-marinoni-moretto-2ypgf/
The Velocity Mirage: why AI tools don't accelerate projects (and what does)
Developers report feeling 20% faster with AI tools, yet METR research (July 2025) shows they're actually 19% slower. This 39-point perception gap explains why 84% AI adoption hasn't improved delivery timelines.
This talk presents Stream Coding, a documentation-first methodology validated through two git-verified production systems:
5Levels Intelligence Platform:
- 7 production-ready modules, 48 tested endpoints
- 1.5-day execution sprint following 5 weeks planning
- Traditional estimate: 4-6 weeks of coding
Preflight Check (Hackathon):
- Complete React app, 59 UI components, 8-hour hackathon
- Team of 3, 4.9 Lovable AI credits
- 3-minute generation, production-ready first deployment
- 2.5 hours upfront planning (strategy + docs combined)
You'll learn: why fast code generation doesn't equal fast projects, how complete specifications reduce debugging cycles dramatically, and quality gates that catch issues during development.
Full methodology: https://github.com/frmoretto/stream-coding
Francesco Marinoni Moretto
Lead AI Architect working on agent-native commerce. Creator of LAR, Stream Coding & Clarity Gate; author of Selling to Agents.
Milan, Italy
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top