35 articles.
Thread-scoped memory covers a single conversation and is persisted through thread-scoped checkpoints. Across-thread long term memory extends beyond individual conversations, stored as JSON documents in a memory store organized by namespaces and keys.
A deep dive into the Ethereum Virtual Machine (EVM) architecture, exploring how it executes smart contracts and manages state in the Ethereum network.
Agents break the habits we built debugging regular software: unbounded inputs, probabilistic outputs, and reasoning you cannot see. The Agent Development Lifecycle — Build, Test, Deploy, Monitor — turns production failures into new tests instead of trying to catch everything before launch.
Explore the Agentic Commerce Protocol (ACP) by Stripe and OpenAI. A guide for TypeScript developers to build AI-driven commerce endpoints for ChatGPT and beyond.
Master AI-powered browser automation using Stagehand and Browserbase. Learn how to debug production issues and automate complex web tasks with TypeScript and LLMs.
Learn how the Check-Effect-Interaction (CEI) pattern prevents reentrancy attacks in Solidity by ordering state updates before external calls.
A technical comparison of Directed Acyclic Graphs (DAGs) and Merkle Trees. Understand their roles in data integrity and blockchain scalability.
Understand ERC-4337 account abstraction and session keys, and how delegated permissions improve security and usability for Ethereum dApps.
LLM outputs are non-deterministic. Without a rigorous evaluation loop, shipping a reliable AI product is guesswork. Notes from Doug Guthrie's Evals 101 workshop at the AI Engineer World's Fair.
Understanding the core engine of Ethereum. This article explores the EVM stack, memory, and storage models that power decentralized applications.
Understand the Free Memory Pointer (FMP) in the EVM: how Solidity allocates memory at 0x40, updates the pointer, and expands dynamic structures safely.
A technical comparison of gRPC and libp2p architectures: client-server versus peer-to-peer, node symmetry, dynamic roles, and the go-libp2p host package.
Learn how to implement a binary search tree in Go with a Node struct, recursive insertion and inorder traversal, plus notes on imbalance and self-balancing trees.
Build a hash table in Golang from scratch: hashing functions, collision handling through separate chaining, resizing strategies, and Go built-in maps.
A step-by-step guide to coding a generic linked list in Golang, covering singly and doubly linked lists, node pointers, and Append and Prepend operations.
Code a generic queue in Golang using slices and structs. This FIFO implementation covers Enqueue, Dequeue, Peek, and IsEmpty operations step by step.
Code a generic LIFO stack in Golang using slices and structs. This implementation covers Push, Pop, Peek, and IsEmpty operations with clear examples.
Understand interfaces in Golang: built-in, external, and custom types, structural typing, polymorphism, and how to implement the error interface with a custom type.
Learn how LangGraph Generative UI enables AI agents to dynamically render interactive React components, bridging the gap between backend logic and frontend UX.
A technical look at precompiles in EVM-based blockchains: their fixed addresses, gas costs, and the cryptographic primitives they expose to Solidity.
An in-depth look at the Raft consensus algorithm. Learn how it manages replicated logs and ensures consistency in distributed systems.
Fix the stack too deep error in Solidity. Learn why the EVM runs out of stack slots and how scoped variables, helper functions, and structs reduce local variables.
Exploring Byzantine Fault Tolerance (BFT) in distributed systems. Learn how blockchains reach consensus even when some participants act maliciously.
Explore the Ethereum zero address and how ERC-20 token burning works: unspendable by design, transparent on-chain, and verifiable through supply reduction.
We spent a decade paying for dashboards. Now agents are collapsing the entire SaaS stack into a single execution loop.
Understand the math behind Uniswap V2: the x * y = k constant product formula, liquidity pool reserves, and how swap amounts are calculated.
Learn how upgradeable smart contracts work in Solidity using the proxy pattern, including the Transparent Proxy and UUPS standards for secure upgrades.
Learn how the OpenZeppelin BitMaps library packs booleans into uint256 words, cutting storage slots and gas costs in Solidity airdrop and voting contracts.
Explore BLS (Boneh-Lynn-Shacham) signatures: elliptic curve pairings, deterministic keys, and signature aggregation for Ethereum validators and ERC-4337.
Understand pointers and pointer receivers in Go: memory addresses, reference passing, and when to use pointer methods to mutate structs without copying values.
How the nonce works inside ERC-4337 UserOperations: it guarantees ordering, ensures uniqueness, and prevents replay attacks in account abstraction.
A guide to ERC-4337 paymasters: how they sponsor gas, pay fees in ERC-20 tokens, and validate UserOperations through the EntryPoint contract.
Explore the Avalanche consensus protocol: repeated random subsampling, metastability, and how nodes reach fast agreement with high throughput and low latency.
An introduction to Bazel, the Google build system for fast, incremental, and reproducible builds across large polyglot monorepos.
How ERC-6900 standardizes modular smart accounts through a plugin architecture inspired by the Diamond Proxy, with separate storage and validation hooks.
