Edge & Node

The Signal Podcast: SPIDER Building Onchain Agents the Right Way, Skills and Beyond! x.com/i/broadcasts/1…

Agentic commerce needs human-oriented guardrails. @ampersend_ai provides human-oriented guardrails. It's as simple as that. @impranavm_ @Marcus_Rein_

Today on the Signal Podcast 🎙️ Dial in with @Marcus_Rein_ and @cryptomastery_ streaming on the Edge & Node X and YouTube at 10 AM PST. 🍿 SPIDER Building Onchain Agents the Right Way, Skills and Beyond!

.@rodventures on the topic of Agentic spending: "API key is a corporate credit card with no spending policy, no approval chain, and no one watching the statement." That's why we're building @ampersend_ai

Blockchains are tamper-evident by design. Every block is cryptographically signed. Every transaction is cryptographically linked. The problem? Most data pipelines ignore these guarantees entirely. Amp verifies data integrity at the extraction layer, before it reaches your systems.

"Software can often be better if its source available..." Choosing to open source Amp was value-aligned for Senior Engineering Manager Ford Nickels @yodataz. Check out the Amp repo linked below ⬇️

For those socialmaxxing we’re hosting a double event this Friday at The House by @edgeandnode We’re opening the doors for an afternoon hang with ice cream, then running it into an Arena Poker Night. Details and RSVP links in thread, may the luck be with you 🧵

Today at Merge in São Paulo 🇧🇷 Catch @rodventures on the panel speaking about blockchain infrastructure for institutions. Starting at 1:10PM at the BingX Stage.

"(Regulators) are not going to look at the blockchain. They're going to look at your data pipeline" @alik_im chatted with @Marcus_Rein_ on why verifiable data extraction is a key compliance requirement for institutions. Amp was built for exactly this moment.

Your smart contract is verified onchain. Your frontend connects to an RPC provider. But everything between those two points is unverified. A typical data pipeline goes: RPC provider ➡️ indexer ➡️ database ➡️ API ➡️ your app. At each step, data can be corrupted through bugs, misconfigs, reorgs handled incorrectly, or outright malicious modification. None of these steps carry cryptographic proof that the data they pass along is correct. A single corrupted log field (like a topic2 in a @Uniswap swap) could misattribute millions in token transfers. This class of bug exists in every unverified pipeline. We spent years building trustless systems, then layered trust assumptions right back on top at the data layer. Amp verifies at extraction using the cryptographic commitments blockchains already provide. The proofs are already in every block header, most pipelines just skip the check.

Amp's architecture is built for cross-chain data. Ingest from multiple chains, join with SQL. This means a single SQL query can access multiple chains all at once. Listen to the full episode between our Senior Engineer @leoyvens and DevRel @Marcus_Rein_ linked below ⬇️

Every NFT trade leaves a data trail. ➡️ raw_logs captures the onchain events. ➡️ transactions links wallet activity to users. ➡️ avatar tracks verified token ownership across chains. Query all of it with SQL directly via Amp.

Compliance-first architecture and verified blockchain data guarantees. That's Amp. @mickeynegus @Marcus_Rein_

There's a pattern in how blockchain data tooling has evolved. Every few years, someone wraps the existing RPC interface in a slightly different abstraction layer, adds some caching, and calls it infrastructure. The underlying problem never gets solved, the complexity just moves to a different part of the stack. You still need an RPC provider. You still need an indexer on top of that. You still need a database under the indexer. You still need custom code to handle reorgs, decode ABI data, and manage schema evolution. Each layer trusts the one below it without verification. The stack gets taller and the failure modes get harder to debug. Amp takes a different approach by collapsing these layers into a single system. It extracts data directly from blockchain nodes, verifies it cryptographically against block header commitments, stores it in columnar format (Parquet), and serves it through SQL with built-in EVM functions for decoding. Reorg handling isn't an afterthought bolted on top. It's a database-level primitive. Amp's streaming consumption model includes TransactionEvent::Undo events that let consumers roll back invalidated data when the chain reorganizes. This is exactly-once semantics applied to blockchain data, the same guarantee you'd expect from a production message queue, but built into the data layer itself. The result is that you can go from "I need to know about every ERC-20 transfer on Ethereum" to a working, verified, streaming data pipeline with a SQL query and a few lines of Rust. No subgraph manifests, no YAML configs, no deploy-and-wait cycles. Standards in (blockchain RPC, EVM ABI specs), standards out (SQL, Arrow, Parquet). The whole thing runs locally on your machine or scales to production. The repo is at github.com/edgeandnode/amp.

Edge & Node CEO @rodventures joins Chainlink and OpenZeppelin to discuss the infrastructure institutions need to deploy and stay compliant onchain. If you’re at @mmerge_io in Brazil, hope to see you there.

Amp stores onchain data in Apache Parquet with block-level partitioning. Parquet is a columnar format designed for analytical workloads. Block-level partitioning means queries that target specific block ranges skip irrelevant data entirely, which is why querying every block hash from genesis returns in 5 seconds. The storage layer is optimized for the access patterns that actually matter in blockchain analytics: time-range scans, aggregations across billions of rows, and joins across datasets. Combined with Apache Arrow as the in-memory format, data moves from disk to query result without serialization overhead. This is the same columnar analytics stack that powers Snowflake, DuckDB, and BigQuery, applied to blockchain data for the first time. github.com/edgeandnode/amp