dataset.json

{
  "train": [
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'."
        },
        {
          "role": "assistant",
          "content": "This week I'm watching: marketplace experimentation around offchain tasks, the emerging \"wallet wars\" for agentic capital, discovery solutions that still feel undifferentiated, and identity standards struggling with spam and legitimacy. Plus a look at what actually makes sense to build right now.\nAfter \\~5 months of posting x402 (nearly every week), the recent explosion of new protocols, standards, and ideas has led me to switch to a broader focus on the agentic economy.\nHere are some of the latest trends, thoughts, and areas of growth I'm watching in the space."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: No. 1 | The Marketplace Revival and Tradeoffs"
        },
        {
          "role": "assistant",
          "content": "### No. 1 | The Marketplace Revival and Tradeoffs\nInterestingly enough, the concept of a marketplace has come in two waves for the crypto industry: NFTs and now agentic tasks. The resurgence of the marketplace has been led by the @daydreamsagents and @virtuals\\_io teams (in my opinion).\nThe unique part about agentic marketplaces is the singular trust assumption that underpins much of blockchain -- the reliance on \"something\" or someone to actually make the call. Why is the concept of an AMM (Automated Market Maker) so powerful? There is no reliance on someone else or something to make the decision.\nThe cool part about an NFT marketplace is that it can operate similarly to an AMM, where there are two assets being swapped in an escrow-like manner. If the conditions are met, the swap is handled and secured by the underlying blockchain.\nSo what happens now when an agent is asking for a task that does **not** occur onchain?\nThe answer: a lot of experimentation around smart contracts, agentic judging, and human arbitration. I don't think this is a negative -- I actually think it's an area ripe for growth.\nOne trend I see: @Executi0nMarket is leading the surge in task markets and agentic marketplaces building on top of @SkaleNetwork."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: No. 2 | The Agentic Wallet Wars"
        },
        {
          "role": "assistant",
          "content": "### No. 2 | The Agentic Wallet Wars\nAgentic wallets are a really interesting idea because they have the same base layer and therefore tradeoffs to keep in mind for developers. A few of the mistakes I'm noticing agentic wallet teams making:\n#### Chain Specific\nOnly supporting a single chain directly limits your adoption. There are SO many good builders experimenting in their own corners of the industry that by only choosing the \"most valuable\" chains today doesn't mean you'll be the winner tomorrow. @OpenWallet from @moonpay is currently the best from a support perspective that I have found.\n#### Cross-chain Capital\nA problem that persists today for many wallets and their underlying blockchains is cross-chain capital. Users having funds on XYZ exchange or wanting to use ABC onramp is great until they want to go do something (or more relevantly, the agent does) elsewhere. Nearly every action at this point incurs a fee of some level. The onramps and wallets who figure out how to better abstract this for agents have a chance to corner the \"non-popular\" chains. The @TrailsHQ by @0xPolygon is one such team; they've enabled one-click bridging to SKALE from nearly any chain, tying directly into the onchain elements that power SKALE.\n#### The Human-in-the-Loop Experience\nThe most nuanced part of AI today: the human. Everyone wants to build agents BUT the agents have to do something for someone. Whether you are building trading agents like @Cod3xOrg (checkout @SkaleNetwork School live stream here on X on 3/31/26 to hear from @uv founder @0xBebis\\_ on this). This is where the harness and the interactions for agents really come into play. The experience to onboard an agent is very much so \"dev-focused\" today, and most of the non-developer focused tooling that isn't a CLI winds up being custodial, which then in some cases can limit how developers want to actually build or how users want to consume."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: No. 3 | Discovery (Feels Like) It Is Lacking a Leader"
        },
        {
          "role": "assistant",
          "content": "### No. 3 | Discovery (Feels Like) It Is Lacking a Leader\nA number of teams have expanded into discovery, such as @agentcashdev from @merit\\_systems, @dexteraisol, @corbits\\_dev, and 402index from @RyanTheGentry with the largest aggregation.\nNatural language discovery tends to be the key (with the behind the scenes being custom per provider) where agents can do something like:\n```\nQuery: I need to generate an image of a cat\nResponse: { json data list of services }\nAgent -> pays via x402/MPP\n```\n*Note, this design tends to be efficient as shown by Codemode from @CloudflareDev.*\nHowever, it feels like agentic builders tend to all converge onto a subset of solutions (often driven by what the LLMs seem to use best, i.e., Next.js, Resend, Postgres, etc.), but the adoption of AI x Crypto crossover is a drop in the bucket compared to that of AI and more broadly development with agentic coding tools.\nTime will tell who becomes the market leader for agentic discovery, but for me, it feels like the winner will bring us something a bit more unique than just search and execute tools.\nFrom a technical perspective, I think all these teams are pushing in the right direction, especially as the basic \"Bazaar\" just doesn't really scale."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: No. 4 | Agentic Identity Stagnation"
        },
        {
          "role": "assistant",
          "content": "### No. 4 | Agentic Identity Stagnation\nThe creation of new agents is occurring at a rapid pace, which is great, but I see one critical flaw with ERC-8004: the ability to curate and create strong feedback is complicated, and spam is hard to avoid.\nI'm ideating on this actively, so if you have ideas and want to chat, let me know. I think ERC-8004 and associative standards will continue to evolve and get stronger, but right now, definitely seeing a struggle around how to know what is legitimate vs. not.\nMaybe private feedback with public approval is one option? I.e., feedback stays private and can be verified by multiple private parties who are rotated (government style) and that they post public scoring based on that?"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: No. 5 | What to Build?"
        },
        {
          "role": "assistant",
          "content": "### No. 5 | What to Build?\nIf you're looking to build SOMETHING and aren't really sure what? My recommendation is to checkout Conditional Transactions from SKALE, where you can bring automated execution of encrypted solidity functionality right into the protocol. Examples include (but are not limited to):\n* Price of token hits X, execute Y\n* Liquidation level hit on lending protocol, auto liquidate small portions\n* Auction ends -> handle payouts\n* Prediction Market closes -> handle payouts\nMore coming in the next week from SKALE.\n***\nA reminder that the above is purely focused on technicals and not legal or financial advice. It is not an endorsement for any tokens. DYOR."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "This article explores three practical ways developers who don't use AI-first workflows can leverage artificial intelligence to enhance their productivity. From generating complex CURL requests through terminal AI tools, to implementing obscure native APIs, and creating comprehensive inline documentation for smart contracts, these targeted applications demonstrate how selective AI integration can streamline development tasks without requiring a complete overhaul of traditional coding approaches.\n> **Update**\n> This was originally written on Nov 4, 2024. AI has accelerated since then -- it's currently July 12, 2025 -- and while AI is far more capable of many things including full blown software development, campaign creation, research, and more; the following use-cases presented here are still fully valid and used often by me.\nOver the last few years I've spent less time coding and more time learning, building documentation, and supporting developers. While I still write software at least two-three times per week and actively juggle a few different software development related projects; I have not really taken advantage of the **AI Boom** at least compared to many of the developers I support and especially from what I've seen at hackathons.\nFor the engineerings out looking for some unique places to slot AI into your workflow instead of using it for **everything,** I have some that have been interesting for me to explore.\nBelow are the **Top 3 Uses Cases** I've found for AI as someone who does NOT use Cursor, v0, and other AI tools on a daily basis.\n#### **Top 3 Use\u00a0Cases**\n##### 1. Creating CURL\u00a0Requests\nCreating CURL requests is something that I\u2019m sufficient at. I can rip out a quick GET or POST request to a test endpoint. I\u2019ve been using\u00a0Warp\u00a0Terminal\u200a\u2014\u200alike many other devs\u200a\u2014\u200afor a number of months now. To be honest, I was originally pretty skeptical when they rolled out the \u201cAsk\u201d Feature late this summer.\u00a0*What did I learn?*\u00a0You can ask Warp to create a CURL request with some of the more complicated information pre-generated for you.\nWorking in the blockchain space, I often want to check \u201csomething\u201d on-chain. Example, double check that my wallet has enough gas tokens.\nHere is an example conversation I had with my terminal asking it to help me check what the balance of the address was.\nTLDR; Using AI to help generate requests can quickly help gather and check on information.\n![](https://cdn-images-1.medium.com/max/1600/1*9u1rwC7qsNFC9pnRndhXxA.png)\nMake requests to Warp AI to quickly check for\u00a0me.\n##### 2. Code Generation for Obscure Native Language\u00a0APIs\nI recently started building the v2 of a distribution platform for\u00a0Eidolon. The Eidolon Console allows users to purchase software development kits (SDKs)\u200a\u2014\u200aprimarily in Unity. The platform is built using the Remix framework which is a Node.js full-stack framework that allows development with React on the frontend and mix-n-match hosting options on the server.\nI\u2019ve found developing with it is quite enjoyable as you can encapsulate logic on the server directly into the route which makes smaller applications far more maintainable.\nRegardless, I fall into what I think is the majority of developers in that I don\u2019t know the majority of the core Node APIs by heart and I definitely need to search quite a bit to figure out which one to use.\nIn this case, I was able to use AI to help me understand how to design a file download from an action route in Remix and return the proper information to the client.\n```ts\n// Other Imports  \n...  \nexport const loader: LoaderFunction = async ({ request }) => {  \n  ...  \n  try {  \n      const response = await s3Client.send(getObjectCommand);  \n      const bodyStream = response.Body as Readable;  \n      // Convert Readable (Node.js stream) to a web ReadableStream  \n      const webStream = new ReadableStream({  \n        start(controller) {  \n          bodyStream.on(\"data\", (chunk) => controller.enqueue(chunk));  \n          bodyStream.on(\"end\", () => controller.close());  \n          bodyStream.on(\"error\", (err) => controller.error(err));  \n        },  \n      });  \n      return new Response(webStream, {  \n        headers: {  \n          \"Content-Type\": response.ContentType || \"application/octet-stream\",  \n          \"Content-Disposition\": `attachment; filename=\"${fileName}\"`,  \n        },  \n      });  \n    } catch (error) {  \n      throw new Response(\"Error fetching file\", { status: 500 });  \n    }  \n}  \n...  \n// Loader + Remix Function Body Below\n```\nAdditionally, when originally setting navigation to this download route; I was running into issues with no actual download occurring and having to chain together redirects to make a smooth experience. I again prompted AI to determine a better way to download without routing to the new page and staying and it provided this code snippet which resolved the issue.\nTLDR; I used AI to help me understand lower level APIs for things that I don\u2019t remember off the top of my head (e.g the window open) and for native API usage which to be candid I never knew to begin with!\n```js\nonClick={(e) => {  \n  e.preventDefault();  \n  window.open(  \n  `/api/download?license=${license.id}`,  \n  \"_blank\"  \n  );  \n}}\n```\n##### 3. Creating Inline Documentation\nThe last one is something that I\u2019ve had other developers chat with me about, but interestingly enough I found it fantastic for smart contracts. While I don\u2019t believe everything needs to be commented fully it is nice to know that libraries can be nicely commented for future developers to build on top of. For example, here is one of the smart contracts I wrote for games to quickly scaffold out on chain Leaderboards. While there may be a bit more than is necessary it was nice to save myself 10\u201315 minutes of writing comments by using AI.\nTLDR; AI is pretty solid at writing clean documentation.\n```solidity\n// SPDX-License-Identifier: MIT  \npragma solidity >=0.8.0 <0.9.0;  \n/// @title Leaderboard  \n/// @author Your Name  \n/// @notice A contract to manage a leaderboard of scores associated with Ethereum addresses  \n/// @dev This contract inherits from the Authority contract and uses role-based access control  \ncontract Leaderboard is Authority {  \n    /// @dev Struct representing a user entry in the leaderboard  \n    struct User {  \n        address user; // The user's Ethereum address  \n        uint64 highScore; // The user's high score  \n        uint64 timestamp; // The timestamp when the score was submitted  \n        uint32 index; // The index of the user in the sorted leaderboard  \n    }  \n    uint32 resetIndex; // Variable used for incremental reset  \n    User[] public leaderboard; // The leaderboard array of User structs  \n    uint32 public maxLength; // The maximum length of the leaderboard  \n    bool public paused; // Flag indicating whether score submission is paused  \n    event IncrementalReset(uint32 indexed amount); // Event emitted when an incremental reset is performed  \n    event Reset(); // Event emitted when the leaderboard is completely reset  \n    event SubmitScore(address indexed user, uint64 indexed highScore); // Event emitted when a score is submitted but not added to the leaderboard  \n    event SubmitScoreAndAdd(address indexed user, uint64 indexed highScore); // Event emitted when a score is submitted and added to the leaderboard  \n    /// @notice Constructor to initialize the contract  \n    /// @param _maxLength The maximum length of the leaderboard  \n    constructor(uint32 _maxLength) {  \n        maxLength = _maxLength;  \n        paused = false;  \n    }  \n    /// @notice Submit a new high score for a user  \n    /// @param user The Ethereum address of the user  \n    /// @param highScore The new high score to be submitted  \n    /// @dev Only callable by the SERVER_ROLE  \n    function submitScore(address user, uint64 highScore) public virtual onlyRole(SERVER_ROLE) {  \n        if (paused) revert(\"Submitted Scores is Paused\");  \n        if (length() >= maxLength && highScore <= leaderboard[length() - 1].highScore) {  \n            emit SubmitScore(user, highScore);  \n            return;  \n        }  \n        _addToLeaderboard(user, highScore, length() >= maxLength ? length() - 1 : length());  \n        _sort(leaderboard, 0, int32(length()));  \n    }  \n    /// @notice Get the current length of the leaderboard  \n    /// @return The length of the leaderboard  \n    function length() public view returns (uint32) {  \n        return uint32(leaderboard.length);  \n    }  \n    /// @dev Internal function to add a new user to the leaderboard  \n    /// @param user The Ethereum address of the user  \n    /// @param highScore The new high score to be added  \n    /// @param index The index at which the new user should be inserted  \n    function _addToLeaderboard(address user, uint64 highScore, uint32 index) internal virtual {  \n        leaderboard.push(User(user, highScore, uint64(block.timestamp), index));  \n        emit SubmitScoreAndAdd(user, highScore);  \n    }  \n    /// @notice Reset the entire leaderboard  \n    /// @dev Only callable by the MANAGER_ROLE  \n    /// @dev Will revert if the leaderboard length is greater than 25,000  \n    function reset() external onlyRole(MANAGER_ROLE) {  \n        if (length() < 25_000) {  \n            delete leaderboard;  \n            emit Reset();  \n        }  \n        revert(\"Reset must be done in increments\");  \n    }  \n    /// @notice Perform an incremental reset of the leaderboard  \n    /// @dev Only callable by the MANAGER_ROLE  \n    /// @dev Removes up to 1,500 entries from the leaderboard  \n    function incrementalReset() public virtual onlyRole(MANAGER_ROLE) {  \n        if (!paused) paused = true;  \n        uint32 removalAmount = length() > 1500 ? 1500 : length();  \n        for (uint32 i = 0; i < removalAmount; i++) {  \n            leaderboard.pop();  \n        }  \n        emit IncrementalReset(removalAmount);  \n    }  \n    /// @dev Internal function to sort the leaderboard array using the quicksort algorithm  \n    /// @param arr The leaderboard array to be sorted  \n    /// @param left The left index of the subarray to be sorted  \n    /// @param right The right index of the subarray to be sorted  \n    function _sort(User[] memory arr, int256 left, int256 right) internal virtual {  \n        int256 i = left;  \n        int256 j = right;  \n        if (i == j) return;  \n        uint256 pivot = arr[uint256(left + (right - left) / 2)].index;  \n        while (i <= j) {  \n            while (arr[uint256(i)].index > pivot) i++;  \n            while (pivot > arr[uint256(j)].index) j--;  \n            if (i <= j) {  \n                (arr[uint256(i)].index, arr[uint256(i)].index) = (arr[uint256(i)].index, arr[uint256(i)].index);  \n                i++;  \n                j--;  \n            }  \n        }  \n        if (left < j)  \n            _sort(arr, left, j);  \n        if (i < right)  \n            _sort(arr, i, right);  \n    }  \n}\n```\nInteresting in using the Sediment contracts? Checkout the docs at\u00a0https://docs.dirtroad.dev/sediment.\n#### **Final Thoughts**\nUsing AI to code is still something I\u2019m learning to do. However, in the meantime these are three things that make a lot of sense for software engineers to start tinkering with AI to boost their problem solving capabilities or handle tedious tasks (like documentation!)."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples."
        },
        {
          "role": "assistant",
          "content": "This article explores how authoritative servers can enhance Web3 applications by preventing bot abuse and managing game state while preserving decentralization benefits through strategic implementation. By leveraging OpenZeppelin's AccessControl for role-based permissions, developers can create secure authority layers that dynamically grant temporary access rights for on-chain actions, with this approach proving most effective on zero-gas-fee blockchains like SKALE that offer instant finality without the operational challenges posed by variable transaction costs and slow confirmation times.\nAuthority is a grey area in Web3. We often want to remove authority in favor of decentralization, yet more often than not we go to far and the end result lacks any benefit back to the user. The following works through an example of why using authority the right way can be so impactful towards a decentralized application (dApp), while also exploring why authority is often ignored by applications due to the underlying network.\n#### An Authoritative Example\nGame developers have been finding innovative ways to push the boundaries of what can be done on-chain. However, whether the in-game actions have value or not one of the biggest issues that Web3 games naturally pick up is bots. While bots are not just a Web3 issue, due to the public nature of smart contracts, individuals can often times run bots that can simulate real users without the knowledge of the developer far easier than they can in a traditional game or app.\n**The Contracts**\\\nFor this example, we will have two smart contracts: An ERC-20 token for the game\u2019s economy, and a bounties contract that manages bounties for the players to accept and work towards.\n```solidity\n// SPDX-License-Identifier: MIT  \npragma solidity ^8.20.0;  \ncontract Token is ERC20 {  \n  constructor() ERC20(\"Token\", \"TKN\") {  \n   _mint(msg.sender, 100000 * 10 ** 18);  \n  }  \n}\n// SPDX-License-Identifier: MIT  \npragma solidity ^8.20.0;  \ncontract Bounties {  \n  using SafeERC20 for IERC20;  \n  IERC20 public token;  \n  mapping(uint256 => uint256) public bounties;  \n  mapping(address => uint64) public cooldown;  \n  modifier onlyHolder {  \n    require(token.balanceOf(msg.sender) > 0, \"Must hold at least 1 wei\");  \n    _;  \n  }  \n  event ClaimBounty(uint256 indexed id, address indexed hunter);  \n  constructor(IERC20 _token) {  \n    token = _token;  \n    for (uint256 i = 0; i < 1000; i++) {  \n      bounties[i + 1] = (i + 1) * 5;  \n     }  \n    }  \n  function claimBounty(uint256 id) external onlyHolder {  \n    require(bounties[id] > 0, \"Bounty already claimed\");  \n    token.safeTransferFrom(address(this), msg.sender, bounties[id);  \n    cooldown[msg.sender] = uint64(block.timestamp);  \n    emit ClaimBounty(id, msg.sender);  \n   }  \n}\n```\nIn theory, these contracts wouldn\u2019t actually be too bad if we wanted to have a fully permissionless game. However, the claimBounty could easily be spammed/botted. As most Web3 games are backed and operated by the creator and are meant to continue to grow, it would be better for the contracts to have some protection to ensure a smooth gameplay experience for everyone.\n#### Authoritative Bounties\n```solidity\n// SPDX-License-Identifier: MIT  \npragma solidity ^8.20.0;  \ncontract Bounties is AccessControl {  \n  using SafeERC20 for IERC20;  \n  bytes32 public constant HUNTER_ROLE = keccak256(\"HUNTER_ROLE\");  \n  bytes32 public constant MANAGER_ROLE = keccak256(\"MANAGER_ROLE\");  \n  IERC20 public token;  \n  mapping(uint256 => uint256) public bounties;  \n  mapping(address => uint64) public cooldown;  \n  event ClaimBounty(uint256 indexed id, address indexed hunter);  \n  constructor(IERC20 _token) {  \n    _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);  \n    _grantRole(MANAGER_ROLE, msg.sender);  \n    _setRoleAdmin(HUNTER_ROLE, MANAGER_ROLE);  \n    token = _token;  \n    for (uint256 i = 0; i < 1000; i++) {  \n      bounties[i + 1] = (i + 1) * 5;  \n     }  \n  }  \n  function addHunter(address hunter) external onlyRole(MANAGER_ROLE) {  \n    require(!hasRole(HUNTER_ROLE, hunter), \"Already a hunter\");  \n    require(uint64(cooldown[hunter]) + uint64(1 days) <= uint64(block.timestamp), \"Cooldown not complete\");  \n    grantRole(HUNTER_ROLE, hunter);  \n  }  \n  function claimBounty(uint256 id) external onlyRole(HUNTER_ROLE) {  \n    require(bounties[id] > 0, \"Bounty already claimed\");  \n    token.safeTransferFrom(address(this), msg.sender, bounties[id);  \n    cooldown[msg.sender] = uint64(block.timestamp);  \n    renounceRole(HUNTER_ROLE);  \n    emit ClaimBounty(id, msg.sender);  \n  }  \n}\n```\n##### **Addition of Roles**\nThe addition of the AccessControl contract by\u00a0OpenZeppelin\u00a0is recommended since it enables the greatest level of flexiblity and scalability. You can setup as many servers as needed with a signer on each and load balance them to manage many calls simultaneously. Additionally, roles compared to ownable makes it simpler to assign different \u201cwallets\u201d to manage different functions while also maintaining scalability.\n##### **An Authoritative Function**\nThe `addHunter` function utilizes the original cooldown functionality in addition to a role. The role is then used temporarily to allow an EOA (externally owned account) to claim a bounty. This authoritative function should be automated through a server\u00a0**OR**\u00a0another smart contract. In most cases this is probably best done through one or more servers, however, for games that have dozens or hundreds of smart contracts; the protection could occur in another contract which then calls out to the bounties.\n##### **The Authoritative Server**\nAuthoritative servers have a number of benefits to a Web3 game. The first and most important part is that they can enable secure authority. The server can act automatically on behalf of a game or an app to do some action(s) on chain. The other nice part is that servers are often used by teams even if they are building a Web3 game from Day 1. This is great because it can help avoid extra expenses for indie developers. Lastly, servers are great because they are flexible with how the blockchain interaction occurs. Many developers choose to use private keys or seed phrases through the environment to be the \u201cauthoritative signers\u201d, however, servers have alternative options like 3rd-party custodial infra like\u00a0Stardust\u00a0or using\u00a0Amazon Web Services (AWS) KMS. Once the signing is in-place the server can now manage the gameplay automatically for you.\n#### Blockchain and Authority\n##### **Gas Fees**\nUnderstanding how gas fees plays into authoritative actions is very important. Chains that have variable gas fees are more difficult to build on for the long term due to the lack of stability in operating costs.\nExample, if the above transaction costs on average $0.01, then every one player claiming 1,000 bounties would essentially incur $10. Any sort of growth on a chain could instantly make fees spike and operating unsustainable.\nChains that offer zero-gas fees have the leg up from both a standard authority approach as well as for teams looking to put more on-chain.\n##### **Consensus and Time to\u00a0Finality**\nRequests from the client to the server take time. Calls from the server to the blockchain take time. Waiting for consensus and then finality takes time.\nCreating user experiences to manage waiting for many blocks to confirm  in addition to the normal time of travel between all these calls can be  highly disruptive. Picking chains that have fast consensus and finality is\u00a0\\\nincredible important. Layer-2\u2019s and Layer-3\u2019s may boast sub-second finality; however the additional rollup generally requires multiple minutes to post and be validated by the Layer 1. Pick wisely to find a protocol that is designed for high throughput, low latency applications.\n##### **SKALE and Authoritative Actions**\nThe\u00a0SKALE Network\u00a0is a great option for building games and applications that use authoritative actions. Thanks to the zero gas fees for developers and end-users; builders on SKALE know they don\u2019t need to worry about variable gas fees EVER.\nAdditionally, with the trio of near-instant finality, no chain forking, and unified validation sending operations from a server to the blockchain and managing the wait time of the user on the client has never been easier.\nLearn more about building on SKALE"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'."
        },
        {
          "role": "assistant",
          "content": "Getting this pipeline right took more effort than expected.\nBun workspaces are fast and clean in local development, but `workspace:*` references do not resolve automatically when publishing a monorepo with npm. If you run `npm publish --workspaces` as-is, npm does not rewrite internal workspace references. In a multi-package setup, that is enough to break publishing.\nA useful starting point was Ian's write-up on Changesets with Bun workspaces:\nhttps://ianm.com/posts/2025-08-18-setting-up-changesets-with-bun-workspaces\nThis post covers the rest: connecting Bun, Turborepo, Changesets, and npm provenance into one release pipeline with three channels:\n* `alpha` from active development branches (`thegreataxios/<branch-name>`)\n* `beta` from `staging` as the integration gate\n* `latest` from `main` as production\nRepository:\nhttps://github.com/thegreataxios/armory\nThe goal was simple: deterministic releases, no manual publishing, no version collisions, and a fast testing loop without release chaos."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: The Model: Alpha for Maintainers, Beta as the Gate"
        },
        {
          "role": "assistant",
          "content": "### The Model: Alpha for Maintainers, Beta as the Gate\nThe critical part is governance, not tooling.\n* `alpha` exists so maintainers can ship installable builds quickly for testing.\n* Non-maintainers do not ship alpha directly. Their path is PR review, then merge to the beta branch first.\n* `beta` is where integration happens. If it passes there, it gets promoted to `main` and published as `latest`.\n`alpha` is a controlled fast lane, not a free-for-all.\n`beta` is the proving ground.\n`main` is the stable line."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Release Channels"
        },
        {
          "role": "assistant",
          "content": "### Release Channels\n| Branch / Context                                          | npm tag  | Meaning                                   |\n| --------------------------------------------------------- | -------- | ----------------------------------------- |\n| Active development branch (`thegreataxios/<branch-name>`) | `alpha`  | Fast iteration builds                     |\n| `staging`                                                 | `beta`   | Integration and release-candidate testing |\n| `main`                                                    | `latest` | Production release                        |\nThis model keeps iteration fast while preserving a predictable promotion path."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Stack"
        },
        {
          "role": "assistant",
          "content": "### Stack\n* Bun for workspace management and runtime\n* Turborepo for build orchestration\n* Changesets for versioning and changelogs\n* GitHub Actions for CI/CD\n* npm `--provenance` for verified publishes\nThe hard part is making Bun workspace protocol semantics compatible with npm workspace publish behavior."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: The Bun Workspace Constraint"
        },
        {
          "role": "assistant",
          "content": "### The Bun Workspace Constraint\nIn a Bun monorepo, internal dependencies often look like:\n```json\n{\n  \"dependencies\": {\n    \"@armory-sh/base\": \"workspace:*\"\n  }\n}\n```\nThat is ideal locally.\nDuring `npm publish --workspaces`, it is not. npm expects concrete semver ranges and will not resolve `workspace:*` references automatically.\nThe fix is straightforward: rewrite workspace references to concrete versions before publish."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Resolving `workspace:*` Before Publish"
        },
        {
          "role": "assistant",
          "content": "### Resolving `workspace:*` Before Publish\n```js\n// scripts/resolve-workspaces.mjs\nconst packagesDir = path.resolve(\"packages\")\nconst packageDirs = fs.readdirSync(packagesDir)\nconst versions = new Map()\n// Collect versions from each workspace package\nfor (const dir of packageDirs) {\n  const pkgPath = path.join(packagesDir, dir, \"package.json\")\n  const pkg = JSON.parse(fs.readFileSync(pkgPath, \"utf-8\"))\n  versions.set(pkg.name, pkg.version)\n}\n// Rewrite workspace:* references\nfor (const dir of packageDirs) {\n  const pkgPath = path.join(packagesDir, dir, \"package.json\")\n  const pkg = JSON.parse(fs.readFileSync(pkgPath, \"utf-8\"))\n  for (const field of [\"dependencies\", \"devDependencies\", \"peerDependencies\"]) {\n    if (!pkg[field]) continue\n    for (const [name, version] of Object.entries(pkg[field])) {\n      if (typeof version === \"string\" && version.startsWith(\"workspace:\")) {\n        const resolved = versions.get(name)\n        if (resolved) pkg[field][name] = resolved\n      }\n    }\n  }\n  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2))\n}\n```\nRun it in CI before publishing:\n```yaml\n- name: Resolve workspace dependencies\n  run: node scripts/resolve-workspaces.mjs\n```\nThis compatibility layer is what makes Bun workspaces reliably publishable through npm in this pipeline."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Where Changesets Fit"
        },
        {
          "role": "assistant",
          "content": "### Where Changesets Fit\nChangesets captures release intent in the PR itself.\nWhen a package changes, the developer adds a changeset:\n```bash\nbun run changeset\n```\nThat produces a `.changeset/*.md` file committed with the PR. Version intent is defined at contribution time; promotion branches then publish that intent under stricter release tags."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Alpha: Fast Maintainer Builds"
        },
        {
          "role": "assistant",
          "content": "### Alpha: Fast Maintainer Builds\nAlpha publishes prioritize speed for maintainers:\n```yaml\n- name: Resolve workspace dependencies\n  run: node scripts/resolve-workspaces.mjs\n- name: Publish alpha\n  run: npm publish --provenance --access public --tag alpha --workspaces\n```\nThis creates installable artifacts quickly for real validation and iteration."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Beta: Integration Gate on `staging`"
        },
        {
          "role": "assistant",
          "content": "### Beta: Integration Gate on `staging`\nNon-maintainer changes flow here first. `staging` publishes beta-tagged release candidates:\n```yaml\n- name: Resolve workspace dependencies\n  run: node scripts/resolve-workspaces.mjs\n- name: Publish packages (beta)\n  run: npm publish --provenance --access public --tag beta --workspaces\n```\nIf the beta release holds up in testing, it is promoted."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Production: Promotion to `main`"
        },
        {
          "role": "assistant",
          "content": "### Production: Promotion to `main`\n`main` is the final step:\n```yaml\n- name: Resolve workspace dependencies\n  run: node scripts/resolve-workspaces.mjs\n- name: Publish packages (latest)\n  run: npm publish --provenance --access public --tag latest --workspaces\n```\nBy this point, release risk should already be low because the artifact has already been exercised upstream."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Enforcing Changesets in CI"
        },
        {
          "role": "assistant",
          "content": "### Enforcing Changesets in CI\nTo block undocumented package changes, CI checks for a changeset whenever `packages/` changes:\n```yaml\n- name: Check for changeset\n  run: |\n    CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD)\n    if echo \"$CHANGED_FILES\" | grep -q \"^packages/\"; then\n      if ! echo \"$CHANGED_FILES\" | grep -q \"^\\.changeset/.*\\.md$\"; then\n        echo \"::error::Packages changed but no changeset found. Run 'bun run changeset'.\"\n        exit 1\n      fi\n    fi\n```\nThis keeps versioning explicit, reviewable, and tied to the PR where code changed."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: npm Provenance"
        },
        {
          "role": "assistant",
          "content": "### npm Provenance\nEvery publish uses provenance:\n```bash\nnpm publish --provenance\n```\nGitHub Actions also needs OIDC permissions:\n```yaml\npermissions:\n  id-token: write\n  contents: write\n```\nThis links published packages to the exact workflow run that built them and marks them as verified on npm."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Outcome"
        },
        {
          "role": "assistant",
          "content": "### Outcome\nThis structure balances speed with control:\n* maintainers can publish quickly when needed\n* contributors follow a clear promotion flow\n* versioning remains intentional and deterministic\n* artifacts are verifiable\nBun provides fast workspace development, Turborepo coordinates builds, Changesets defines release intent at the PR layer, and npm distributes verified artifacts.\nOnce these pieces are wired together, releases become repeatable and uneventful, which is exactly what a CI/CD pipeline should optimize for."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers."
        },
        {
          "role": "assistant",
          "content": "The machine economy needs privacy. With Confidential MPP on SKALE, agents pay and get paid without exposing amounts or balances. Financial details stay between the parties, not on the chain.\n***\n**SKALE** is a blockchain network purpose-built for the Internet of Agents. Unlike general-purpose chains where every transaction is broadcast publicly, SKALE provides configurable privacy through threshold encryption\u2014validator nodes collaborate to decrypt transactions only when protocol conditions are met. Combined with a pre-paid credit system for computation and instant finality, SKALE enables agents to transact thousands of times per day with Web2-like economics and Web3-grade security.\n**MPP** (Machine Payments Protocol) is an open standard co-developed by Stripe and Tempo for machine-to-machine payments. Built on HTTP 402 (Payment Required), MPP defines how autonomous agents discover paid services, negotiate terms, and execute transactions\u2014without manual signup, API keys, or browser automation. Any service can accept payment from any client through a standardized challenge-credential-receipt flow: the server returns a `402 Payment Required` response with available payment options, the client fulfills the payment (via cards, stablecoins, or blockchain), and retries with proof of payment. The resource is delivered with a receipt for verification.\n**The problem:** MPP on transparent blockchains exposes everything. Agent spending patterns. Strategic preferences. On public ledgers, your AI agent is effectively publishing its financial diary\u2014visible to competitors, front-runners, and anyone with a block explorer.\n**Confidential MPP on SKALE** fixes this. By combining MPP's payment protocol with SKALE's native threshold encryption, agents can pay for services without revealing transaction details to the network. Only the sender and recipient see the actual payment data. Validators process encrypted transactions collaboratively\u2014no single node ever holds the decryption key.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: MPP Protocol"
        },
        {
          "role": "assistant",
          "content": "### MPP Protocol\nMPP addresses a fundamental gap in internet infrastructure: there is no standard way for machines to pay for services programmatically. While humans have optimized checkout flows, browser automation pipelines struggle with visual CAPTCHAs, payment form changes, and session management. This creates friction for AI agents that need to consume paid APIs at scale.\nMPP solves this through a simple, extensible core built on an open IETF specification:\n* **Challenge:** The server returns `402 Payment Required` with a `WWW-Authenticate: Payment` header listing supported methods (Stripe cards, Tempo stablecoins, Solana, Lightning, etc.)\n* **Credential:** The client fulfills payment and retries with `Authorization: Payment` containing proof of payment\n* **Receipt:** The server verifies payment and returns the resource with `Payment-Receipt` header as proof of delivery\nThis works with any currency\u2014USD, EUR, USDC, BTC\u2014and any payment network. Developers build MPP clients so their agents can pay for LLM inference, image generation, web search, and data APIs. Service operators integrate MPP servers to accept payments without complex billing infrastructure.\nOfficial SDKs are maintained by Tempo Labs and Wevm in TypeScript, Python, and Rust.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: SKALE's Privacy Architecture"
        },
        {
          "role": "assistant",
          "content": "### SKALE's Privacy Architecture\nSKALE provides three native privacy primitives built on the **BITE Protocol** (Blockchain Integrated Threshold Encryption) and integrated directly into the blockchain protocol:\n**Encrypted Transactions:** Transactions are encrypted from wallet to execution. The mempool contains only ciphertext\u2014validators cannot see transaction details until a supermajority collaborates to decrypt at execution time. This eliminates MEV and front-running while keeping amounts and payloads private.\n**Conditional Transactions (CTX):** Smart contracts can prepare encrypted transactions that execute automatically when predefined conditions are met. Useful for automation workflows and private state transitions\u2014contracts commit to outcomes without revealing inputs until execution triggers.\n**Re-encryption:** Encrypted data can be re-encrypted for new recipients onchain. This enables private data sharing where information remains encrypted throughout its lifecycle, accessible only to intended parties without exposing plaintext to the network.\n**Confidential Tokens:** A production implementation that combines all three primitives with standard Solidity to create tokens with private balances and amounts. Transfers execute through encrypted transactions, balances remain hidden from the contract itself, and recipients can be designated through re-encryption. The result is fully private stablecoin transfers\u2014neither amounts nor balances visible onchain.\nAll primitives and the Confidential Token implementation are available on SKALE chains today. Developers use standard Solidity, Hardhat, and Foundry\u2014no custom VMs, no circuit languages, no rewrites required.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: How Confidential MPP Works"
        },
        {
          "role": "assistant",
          "content": "### How Confidential MPP Works\n#### Standard MPP\nStandard MPP flow on a transparent chain:\n```\nAlice (Agent) \u2192 Bob (Service) \u2192 Blockchain\n     \u2502                \u2502\n     \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n              Everyone sees the payment\n```\nAlice signs. Bob verifies. The blockchain records amounts and balances publicly. This fails **The Barista Test**: when you buy coffee, the barista doesn't see your bank balance. Your AI agent shouldn't broadcast its wallet state either.\n#### Confidential MPP\nConfidential MPP adds encryption at the protocol level:\n```\n\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510      \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510      \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n\u2502 Alice (Agent)\u2502\u2500\u2500\u2500\u2500\u2500>\u2502 Bob (Service)\u2502\u2500\u2500\u2500\u2500\u2500>\u2502  Blockchain  \u2502\n\u2502              \u2502      \u2502              \u2502      \u2502              \u2502\n\u2502  a. Signs    \u2502      \u2502  b. Encrypts \u2502      \u2502  c. Executes \u2502\n\u2502     tx       \u2502      \u2502     tx       \u2502      \u2502     private  \u2502\n\u2502     \u2193        \u2502      \u2502     \u2193        \u2502      \u2502     transfer \u2502\n\u2502   sends      \u2502      \u2502   submits    \u2502      \u2502              \u2502\n\u2502   to Bob     \u2502      \u2502   to chain   \u2502      \u2502              \u2502\n\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n        \u2502                     \u2502                     \u2502\n        \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n                  Only Alice and Bob see the payment\n```\n**The flow:**\n1. **Signed by Alice** \u2014 Alice signs the payment request and sends it to Bob\n2. **Encrypted by Bob** \u2014 Bob encrypts the transaction details using the network's public key before submitting to the chain\n3. **Blockchain execution** \u2014 Encrypted data hits the chain. Validators see ciphertext, not plaintext\n4. **Threshold decryption** \u2014 When conditions are met, a supermajority of validators collaboratively decrypt (no single party ever sees the full plaintext)\n5. **Private transfer** \u2014 The smart contract executes the private balance transfer with decrypted values\nThe key: **no single validator can decrypt alone**. A supermajority must collaborate, ensuring decryption only happens when protocol conditions are satisfied.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Using the SDK"
        },
        {
          "role": "assistant",
          "content": "### Using the SDK\nInstall:\n```bash\nnpm install @skalenetwork/mpp\n```\nMake a confidential payment:\n```typescript\nconst method = mpp.charge({\n  chain: 'bite-sandbox',\n  currency: 'eUSDC',\n  extensions: {\n    skale: { encrypted: true, confidentialToken: true },\n    gasless: 'eip3009'\n  }\n})\n```\n**What this does:**\n* `encrypted: true` \u2014 Transaction amount is encrypted onchain\n* `confidentialToken: true` \u2014 Uses eUSDC, where token balances are also encrypted\n* `gasless: 'eip3009'` \u2014 No gas fees (EIP-3009 permit signature)\nBoth the payment amount and the token balances remain private. Only the sender and recipient can decrypt their own data.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Why SKALE for Confidential MPP"
        },
        {
          "role": "assistant",
          "content": "### Why SKALE for Confidential MPP\n**Native privacy infrastructure.** Encrypted transactions and confidential tokens are integrated directly into the blockchain protocol\u2014no external proving systems, no third-party dependencies. SKALE chains handle millions of transactions per day each, with infinite horizontal scaling across the network.\n**Pre-paid credit system.** SKALE Base uses a credit-based model where developers pre-purchase computation capacity. Agents execute thousands of microtransactions per day with highly efficient costs\u2014no volatile gas fees, no ETH required, and full EVM compatibility maintained.\n**EVM-native.** Use existing Solidity contracts, Hardhat, Foundry, and standard tooling. No circuit languages, no custom VMs, no rewrite required.\nThe infrastructure exists now. SKALE provides the privacy primitives. MPP provides the payment protocol. Together they enable AI agents to transact without broadcasting their financial lives to the world.\n***\nSawyer Cutler is VP Developer Success at SKALE and builds AI systems."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples."
        },
        {
          "role": "assistant",
          "content": "SKALE Network's Blockchain Integrated Threshold Encryption (BITE) Protocol introduced **Encrypted Transactions** which introduced 100% private data in transit for blockchain transactions from wallet to execution.\nThis was a massive step \u2014 removing mempool visibility, eliminating front-running, and giving agents encrypted execution. Encrypted Transactions operate on data in motion. Once data lands in contract storage, it's plaintext. Anyone with a block explorer can read it.\nCTXs (Conditional Transactions) change this. Encrypted data can now live inside smart contract state and only decrypt when the contract explicitly triggers it.\nFor AI agents, this distinction is more important than it initially seems."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: What CTXs Actually Do"
        },
        {
          "role": "assistant",
          "content": "### What CTXs Actually Do\nEncrypted Transactions encrypt the transaction itself \u2014 the calldata, the destination, the intent. Validators reach consensus on the encrypted payload and only decrypt after finalization. That solves MEV and intent leakage.\nCTXs introduce a new EVM primitive, **conditional execution**. This allows encrypted data to be stored onchain and decrypted inside a smart contract when a developer-defined condition is met. The mechanism is implemeted as a callback pattern (similiar to Chainlink VRF):\n1. A user or agent submits encrypted data to a contract. The data stays encrypted in storage.\n2. When conditions are met, the contract calls `BITE.submitCTX(BITE.SUBMIT_CTX_ADDRESS, msg.value / tx.gasprice, encryptedArgs, plaintextArgs);`\n3. The transaction queues and in the next block, the validator committee performs threshold decryption in a batch.\n4. The decrypted data passes to the developer's `onDecrypt()` callback, which executes the business logic with the sender being an ephemeral wallet.\nThis is a two-block operation. Block *i* queues the decryption request. Block *i+1* decrypts and executes. This breaks the standard EVM assumption that contract execution is atomic within a single block \u2014 more on that below."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Why This Matters for AI Agents"
        },
        {
          "role": "assistant",
          "content": "### Why This Matters for AI Agents\nEncrypted Transactions protect agents intent in transit. CTXs protect agents intent at rest.\nAn AI agent's value is in what it knows and how it decides. Strategy parameters, pricing models, risk thresholds, coordination state \u2014 these are the things that make an agent competitive. On a standard EVM chain, storing any of this onchain means publishing it to the world.\nCTXs create a new category of onchain data: encrypted state that is only readable when the contract decides it should be.\n|                     | Encrypted Transactions                   | CTXs                                               |\n| ------------------- | ---------------------------------------- | -------------------------------------------------- |\n| What's encrypted    | Transaction data (calldata, destination) | Smart contract storage (state, parameters, inputs) |\n| When it's decrypted | After block finalization                 | When contract triggers `BITE.submitCTX()`          |\n| Protection model    | Transit encryption                       | At-rest encryption with conditional reveal         |\n| Developer interface | Transparent (automatic)                  | Callback pattern (`onDecrypt()`)                   |\n| Execution model     | Same-block                               | Two-block (request in *i*, execute in *i+1*)       |\nFor agents, this enables workflows that were previously not possible on any public chain:\n**Encrypted strategy parameters.** A trading agent can store its rebalancing thresholds, price triggers, and position limits encrypted onchain. The contract only decrypts and executes when market conditions match. Observers see that something was triggered \u2014 they don't see what the thresholds were.\n**Sealed agent-to-agent negotiations.** Two agents submit encrypted terms for a task. The contract decrypts both simultaneously when both sides have submitted and executes on the overlap. Neither agent sees the other's terms until reveal, eliminating first-mover disadvantage.\n**Conditional autonomous payments.** An agent's payment triggers only fire after a decryption event confirms a condition \u2014 delivery of data, completion of compute, verification of a result. This is \"if/then\" financial logic enforced by the chain instead of a centralized scheduler or human operator."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: The Two-Block Model"
        },
        {
          "role": "assistant",
          "content": "### The Two-Block Model\nThis is the part that requires a shift in thinking for EVM developers.\nEVM developers are trained on atomicity. You call a function, the state changes, the transaction either succeeds or reverts \u2014 all in one block. CTXs break that assumption.\nWhen a contract calls `BITE.submitCTX()`, the decryption does not happen in the current block. It is batched with all other decryption requests from block *i* and executed at the start of block *i+1*.\nThis means:\n* You cannot read the decrypted result in the same transaction that requested it\n* Your logic must be structured as a callback, not a synchronous read\n* Multiple decryption requests from the same block batch together\nThe batching is what makes many of the most interesting use cases possible. A sealed-bid auction where all bids decrypt simultaneously in a single batch is fundamentally more fair than sequential reveals. A prediction market where all predictions unseal at the same time eliminates timing advantages entirely.\nIf you've worked with SKALE's native RNG, the mental model is similar \u2014 the value is derived from the consensus process and is available in the next block, not the current one."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: What You Can Build"
        },
        {
          "role": "assistant",
          "content": "### What You Can Build\nHere are some concrete patterns that CTXs unlock. Each one is directly relevant to AI agent systems:\n#### Sealed-Bid Auctions\nAgents submit encrypted bids. The contract collects them until a cutoff time. At that point, all bids decrypt in a single batch and the winner is selected. No sniping. No timing advantages. No bid surveillance before the reveal.\nAn AI procurement agent bidding for compute resources or data access can submit a sealed bid without revealing its budget constraints to competitors.\n#### Conditional Trading Triggers\nAn agent encrypts conditions like \"If ETH > $5,000, sell 10 ETH.\" The exchange contract stores the encrypted condition. When a price oracle reports the threshold, the contract triggers `BITE.submitCTX()`, decrypts the condition, and executes.\nThe strategy is private until the moment it fires.\n#### Time-Locked Reveals\nEncrypted data that automatically decrypts at a specific block timestamp. A research swarm that publishes findings simultaneously, a prediction market where all predictions seal until the event resolves, or an agent that pre-commits to an action but keeps it hidden until execution time.\n#### Sealed Negotiations\nTwo agents submit encrypted negotiation terms. The contract only decrypts when both sides have submitted, and both are revealed simultaneously. Execution happens on the overlap of terms.\nThis is the foundation of private agent-to-agent commerce where neither party has an information advantage. As I explored in Memory for the Agentic Economy, agent marketplace transactions need transparent execution and settlement records \u2014 but the *terms* can remain private until reveal.\n#### Encrypted Multisig Updates\nAn encrypted contract update is submitted. It stays encrypted until a threshold of multisig approvals is reached. Attackers cannot see what the update contains until it is already approved. This protects governance operations from front-running and social manipulation."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: What This Means for SKALE on Base"
        },
        {
          "role": "assistant",
          "content": "### What This Means for SKALE on Base\nAll of this runs on SKALE on Base \u2014 zero gas, instant finality, and now encrypted smart contract state.\nFor agents operating through x402 payment flows, CTXs mean payment conditions can be encrypted until they fire, keeping agent budgets and spending logic private. Agent coordination state \u2014 task assignments, resource allocation, bid history \u2014 can live onchain without being readable by the world. x402 facilitators can implement more complex settlement schemes where encrypted conditions govern when funds move.\nCombined with SKALE's credit system and sub-second finality, CTXs make SKALE on Base the first environment where AI agents can store state onchain with the same confidentiality expectations they have in private cloud infrastructure.\nIf you are building agents that need private onchain state, reach out. I'm working on this daily and happy to walk through integration patterns."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers."
        },
        {
          "role": "assistant",
          "content": "The LLM will fail. Not sometimes, not in edge cases \u2014 regularly, unpredictably, and in ways that are hard to reproduce. It will return prose instead of a tool call, use action names that do not exist, invent parameter values outside the valid range, or return nothing at all. Building an agent that survives this means designing for LLM failure at every layer of the architecture.\nMost agent frameworks treat model errors as exceptions to handle in the calling code. The model generates output, the application validates it, and if it is wrong the application tells the model to try again. This works in a chat loop where the user is waiting and the cost of a retry is a few seconds of latency. It does not work in an agent loop where the environment changes between iterations, other actors modify shared state, and the agent cannot ask for help.\nThis post walks through a concrete architecture that handles LLM failure at every layer: enforcing tool calls at the infrastructure level rather than relying on the model to format them correctly, layering deterministic fallbacks underneath the LLM so a bad model output never reaches the environment, persisting state across restarts with verification against live state, and building an audit trail that turns every failure into training data for the next iteration. The architecture is built around a poker agent \u2014 it holds a wallet, reads its cards, signs transactions, and keeps playing until it runs out of money \u2014 but the patterns apply to any agent operating in a live, irreversible environment."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Three Common Agent Patterns"
        },
        {
          "role": "assistant",
          "content": "### Three Common Agent Patterns\nThere are more ways to build an agent than there are people building them, but three patterns come up repeatedly in conversations and each has different tradeoffs around control, security, and predictability.\nThe confusion between these two architectures is understandable because they look similar at the code level. Both involve a model that generates text and calls tools. The difference is in the control flow, the state model, and the failure handling.\nA chat loop processes one user request at a time. The model receives the conversation history, decides whether to call tools, and generates a response. The application executes any tool calls, appends the results to the conversation, and the model generates a final answer. The session is bounded by the user's patience and the context window. If a tool call fails, the model can try a different approach or admit defeat. The user can always say \"try again\" or \"do it differently.\"\nAn agent loop has no natural boundary. It runs until it is stopped, crashes, or exhausts its resources. It cannot ask a human for help because there is no human in the loop. Every tool call must produce a valid result or the agent needs to handle the failure independently. The state of the environment changes between loop iterations \u2014 other actors modify shared state, timing constraints expire, resources become unavailable \u2014 so the agent cannot assume the world looks the same as it did during the previous iteration.\n| Property                | Chat Loop                 | Agent Loop                    |\n| ----------------------- | ------------------------- | ----------------------------- |\n| Control flow            | Request-response, bounded | Continuous, unbounded         |\n| State model             | Conversation history only | Persistent across iterations  |\n| Human in loop           | Yes                       | No                            |\n| Failure handling        | Can ask for help          | Must handle independently     |\n| Environment assumptions | Static during request     | Changes between iterations    |\n| Tool call expectations  | Best effort, retriable    | Must succeed or have fallback |\nThe poker agent maps cleanly onto the agent loop side of this table. It runs as a `while (true)` loop that only exits on fatal errors. It maintains session state across hands and recovers from crashes by verifying its seat onchain. It cannot ask for help when it does not know what to do \u2014 it has a deterministic fallback policy for exactly that situation. The environment (other players, the blockchain state, the blind structure) changes every hand and the agent needs to re-read state before every decision.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Why Tool Calling Works Differently in an Agent Loop"
        },
        {
          "role": "assistant",
          "content": "### Why Tool Calling Works Differently in an Agent Loop\nThe most common approach to tool calling in chatbots is to give the model a list of tools and trust it to format them correctly, and this works reasonably well in a chat loop because the cost of failure is low. Consider a weather chatbot: the model returns `getWeather location: Austin` instead of the expected JSON format, the application catches the error and tells the model to retry, the model corrects itself, and the user gets their answer one extra round-trip later. The conversation continues, nobody loses anything, and the user probably did not even notice the delay.\nNow consider the same kind of error in an agent loop. The poker agent is in the middle of a hand and needs to act before the turn passes. The model returns prose instead of a `submit_action` call \u2014 something like \"I think I should raise to 500\" with no tool call attached. There is no human to correct it, no opportunity to retry, and the blockchain does not wait. The turn expires, the agent folds by default, and the buy-in is lost. The same model behavior that produced a minor inconvenience in the chatbot produces a financial loss in the agent loop.\nThe errors are not limited to missing tool calls. The model might call `submit_action` with an action of \"all-in,\" which is not a valid action in the contract (only fold, check, call, and raise exist), or it might provide a raise amount that is below the table minimum. In a chatbot, these would trigger a validation error and a retry. In the agent loop, by the time the error propagates and the agent could retry, the turn has already passed to the next player.\nEven correct tool calls can fail due to timing. The model calls `get_game_state`, sees that it is its turn, spends a few seconds reasoning, and then calls `submit_action`. In a chatbot this would be fine because the environment does not change while the model is thinking. In the agent loop, another player may have acted between the state read and the action submission, meaning the agent is now betting out of turn and the contract rejects the transaction. The agent cannot simply re-read state and retry because the turn has passed.\nThese failure modes lead to a different design philosophy for tool calling in agent loops:\n**Enforce tool choice at the infrastructure level.** The agent creates a dedicated model instance for decision-making that is configured with `tool_choice: \"required\"`, meaning the model must call at least one tool on every turn:\n```typescript\nfunction createSubmitActionCaller() {\n  return createModel().bindTools(\n    [submitAction],\n    { tool_choice: \"required\", strict: true },\n  )\n}\n```\n**Prefer broad tool requirements over narrow ones.** The `\"required\"` option forces at least one tool call without prescribing which tool, and this turns out to be significantly more reliable than requiring a specific tool. When pinned to `submit_action`, models refuse more often \u2014 they hit uncertainty about the exact raise amount and freeze. With `\"required\"`, the model can call `read_hole_cards` to verify its hand or `get_game_state` to recheck the board before committing, and the compliance rate goes up because the model has an escape valve for uncertainty.\n**Give the model permission to reason before acting.** The original prompt told the model \"Return exactly one submit\\_action tool call now. Do not answer with text,\" which caused Claude to say \"I understand the instructions\" and return nothing \u2014 not a refusal, not a tool call, just empty output. The current prompt produces better results:\n```\nThink step by step about your decision, then call submit_action with your chosen action.\n```\nGiving the model room to reason before committing improves tool call reliability significantly because the model arrives at confidence before it has to act, and the `\"required\"` tool choice ensures that confidence produces a concrete action rather than more prose.\n**Validate output at the parsing layer, not just the tool layer.** Even with `\"required\"` tool choice, the model can return malformed or invalid tool calls. The agent parses responses through an extraction function that handles two possible output shapes \u2014 direct tool calls from the model and the `{ messages }` wrapper from Deep Agents \u2014 and validates the action type before executing:\n```typescript\nfunction extractSubmitActionArgs(response, tableAddress) {\n  const toolCall = extractToolCalls(response)\n    .find(call => call.name === \"submit_action\")\n  if (!toolCall || !toolCall.args) return null\n  const args = toolCall.args\n  if (!isPokerAction(args.action)) return null\n  return {\n    tableAddress,\n    action: args.action,\n    raiseAmount: args.action === \"raise\" ? args.raiseAmount : null,\n  }\n}\n```\nIf `extractSubmitActionArgs` returns null \u2014 which happens roughly 10-30% of the time depending on the model and provider \u2014 the agent does not retry or ask for clarification because the turn would pass before the model could respond. It immediately invokes the deterministic fallback policy, which runs in microseconds and always produces a legal action.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: The Risk-Reward of Fallback Strategies"
        },
        {
          "role": "assistant",
          "content": "### The Risk-Reward of Fallback Strategies\nThe core design question for any agent loop is: what happens when the model fails to produce a valid action? There are three common approaches, and each has different cost and risk characteristics.\n**Approach 1: Auto-retry the LLM.** The agent re-prompt the model with the error context and ask it to try again. This is the most common pattern in chatbot architectures and the default behavior of most agent frameworks. The advantage is that the model might correct itself on the second attempt \u2014 perhaps it needed the error feedback to get the formatting right. The disadvantage is that retrying costs tokens, consumes time, and is not guaranteed to succeed. In the poker agent, a retry takes 2-5 seconds, during which the turn may pass and the agent forfeits the hand. Each retry also doubles the token cost of the decision. If you retry three times and the model still fails, you have spent three times the tokens and still need a fallback.\n**Approach 2: Fall back to a human.** Escalate the decision to a human operator when the model cannot produce a valid action. This works well in systems where latency is acceptable and human oversight is desired, but it breaks the autonomy guarantee of the agent loop. If the agent is running at 2 AM and needs to act within 30 seconds, a human fallback means the agent fails by default. For the poker agent, this approach is not viable because the game does not pause while waiting for a human to review the board.\n**Approach 3: Deterministic fallback policy.** Use a hardcoded decision engine that runs in microseconds and always produces a legal action. This is the approach I used. The policy cannot bluff or make sophisticated reads, but it never refuses, never hallucinates, and never costs more than a few microseconds of CPU time. The tradeoff is between strategic creativity and guaranteed uptime.\nThe poker agent uses a three-layer architecture that attempts all three approaches in order, with the most creative but least reliable layer running first and the least creative but most reliable layer running last. Each layer catches the failures of the layer above it.\n**Layer 1: The LLM.** The model produces a reasoned decision based on game state, cards, persona, and phase context. This is the most creative layer \u2014 it can bluff, read opponents, make sophisticated pot-odds calculations, and adapt its strategy. It is also the least reliable, producing valid tool calls roughly 70-90% of the time depending on the provider.\n**Layer 2: The deterministic policy.** A 200-line poker engine that classifies hands and computes actions without calling any model. Preflop it checks for premiums, pairs, broadways, and suited connectors. Postflop it evaluates made-hand strength on a 0-8 scale and checks for draws. It runs in microseconds, never refuses, and never hallucinates invalid actions. It produces a reasonable action 99% of the time, though it lacks the creativity to bluff or exploit opponent tendencies.\n```typescript\nfunction preflopDecision(state, holeCards) {\n  const code = handCode(holeCards)\n  const premium = isPair(code) && pairRank(code) >= rankIndex(\"T\")\n    || [\"AKs\", \"AQs\", \"AJs\", \"KQs\", \"AKo\"].includes(code)\n  if (premium && !facingRaise) return { action: \"raise\", raiseAmount: openSize.toString(), reason: `${code} is a value open heads-up with dynamic sizing.` }\n  if (canCheck) return { action: \"check\", raiseAmount: null, reason: `${code} can realize equity for free.` }\n  if (!facingRaise || playable) return { action: \"call\", raiseAmount: null, reason: `${code} is playable at current price.` }\n  return { action: \"fold\", raiseAmount: null, reason: `${code} is too weak against a real raise.` }\n}\n```\n**Layer 3: The last resort.** If both the LLM and the deterministic policy fail to produce an action that the contract accepts, the agent uses a simple rule: call if facing a bet, check otherwise. This is not strategic in any sense. It exists purely to keep the agent legal when everything else has failed.\n```typescript\nfunction getFallbackAction(state) {\n  const currentBet = BigInt(state.currentBet ?? \"0\")\n  const myBet = BigInt(state.myBet ?? \"0\")\n  return currentBet > myBet ? \"call\" : \"check\"\n}\n```\n| Layer | Source               | Speed        | Creativity | Reliability |\n| ----- | -------------------- | ------------ | ---------- | ----------- |\n| 1     | LLM                  | Seconds      | High       | \\~70-90%    |\n| 2     | Deterministic policy | Microseconds | Medium     | \\~99%       |\n| 3     | Last resort          | Microseconds | None       | 100%        |\nThe layered approach avoids the downsides of each individual strategy. Auto-retry would burn tokens and time while still needing a fallback when it eventually fails. Human escalation would break autonomy and fail under time pressure. The deterministic policy runs fast enough that it can be invoked after every failed LLM call without meaningful delay, and the last resort ensures the agent always produces a legal action even when the policy encounters an edge case it was not designed for.\nMost agent frameworks only implement layer 1 with a retry loop. Adding a fallback policy that runs at a different speed and has different failure characteristics makes the system much more robust than any single layer could be.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Strategy as Data, Not Prompting"
        },
        {
          "role": "assistant",
          "content": "### Strategy as Data, Not Prompting\nI defined six strategy personas \u2014 wolf, bull, owl, fox, shark, cat \u2014 as a way to make the system prompt easy to track and experiment with. Each persona is a set of numeric parameters consumed by both the prompt and the deterministic policy, which means changing the strategy is a data change rather than a prompt rewrite.\n```typescript\ninterface PersonaConfig {\n  name: string\n  philosophy: string\n  aggression: number\n  tightness: number\n  bluffFrequency: number\n  adaptSpeed: number\n  riskTolerance: \"low\" | \"medium\" | \"high\"\n  positionalRules: string\n  handSelection: string\n  bluffConditions: string\n  adaptationRules: string\n}\n```\n| Persona | Aggression | Tightness | Bluff Frequency | Playing Style                                          |\n| ------- | ---------- | --------- | --------------- | ------------------------------------------------------ |\n| Wolf    | 0.55       | 0.55      | 0.25            | Balanced game-theory-optimal with adaptive adjustments |\n| Bull    | 0.90       | 0.20      | 0.40            | Extreme pressure, raises constantly                    |\n| Owl     | 0.35       | 0.90      | 0.05            | Tight, mathematical, premium hands only                |\n| Fox     | 0.55       | 0.45      | 0.45            | Tricky, semi-bluffs, exploits weaknesses               |\n| Shark   | 0.75       | 0.80      | 0.10            | Patient, calculated, strikes selectively               |\n| Cat     | 0.50       | 0.50      | 0.35            | Unpredictable, mixed strategy                          |\nThe parameters are serialized into the system prompt at startup, giving the model a clear behavioral identity. The same parameters feed the deterministic policy when the model fails, so the fallback action reflects the same strategy the model would have chosen. A bull that cannot decide still acts like a bull \u2014 it raises instead of folding \u2014 because the policy uses the persona's aggression and tightness values.\nThis matters beyond poker. Any agent with a configurable strategy should encode that strategy as data that both the model and the fallback mechanism can consume. If your deterministic fallback does not reflect the same behavioral model as your prompt, you introduce inconsistency where the agent acts one way during normal operation and a different way under stress.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: State Persistence and Recovery"
        },
        {
          "role": "assistant",
          "content": "### State Persistence and Recovery\nAn agent loop that cannot survive a crash is not production-ready. The agent needs memory across sessions \u2014 not just for long-term learning, but for basic recovery when the process dies and restarts.\nThe poker agent uses a memory backend interface with three implementations: an in-memory store capped at 1000 entries, SQLite via Bun's native driver, and Postgres for multi-agent deployments. The critical piece is the session state, which stores the agent's table address and seat position so it can recover after a restart.\n```sql\nCREATE TABLE IF NOT EXISTS session_state (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL,\n  updated_at TEXT NOT NULL DEFAULT (datetime('now'))\n);\n```\nOn boot, the agent loads its session and verifies it is still seated by calling `getPlayer()` on the contract for each active player. If the address matches, it readies up and continues playing from where it left off. If the seat is gone \u2014 perhaps the agent was force-removed during downtime, or the contract was reset \u2014 it clears the stale session and discovers a new table.\nThis verification step is the important detail. You cannot trust the persisted session unconditionally because the world may have changed while the agent was offline. The agent must verify its assumptions against the live environment before proceeding. Many agent implementations skip this step and get stuck trying to operate on state that no longer exists.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: The Audit Trail Is the Seed for Self-Learning"
        },
        {
          "role": "assistant",
          "content": "### The Audit Trail Is the Seed for Self-Learning\nThe agent logs every action with its raw reasoning, the game state snapshot at decision time, and the action that was actually submitted onchain. This creates a complete record of what the agent saw, what it thought about it, and what it did.\nThis log serves two immediate purposes. First, it creates an audit trail for investigating failures after the fact \u2014 without the game state snapshot, debugging an agent that folded a winning hand hours ago is nearly impossible because the context that led to the decision is gone. Second, it provides a training data pipeline for the next iteration of the agent.\nThe next step is to use this log to build a self-learning loop. Each logged decision is a labeled example: given this game state and these cards, the agent chose this action. Over thousands of hands, this becomes a dataset for fine-tuning the model on its own play history, or for training a smaller model that handles routine decisions while the larger model handles complex situations. The logging infrastructure that exists for debugging today is the training pipeline for tomorrow.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: The Hardest Part Is the Infrastructure"
        },
        {
          "role": "assistant",
          "content": "### The Hardest Part Is the Infrastructure\nThe problems that broke the agent during development had nothing to do with the model. Every agent loop that interacts with external systems will encounter equivalent problems regardless of the environment, and they will consume more debugging time than the model ever will.\n* **Resource availability.** An agent needs a minimum balance of whatever resource its environment requires to operate \u2014 gas on a blockchain, API credits on a SaaS platform, compute time on a cloud function. The agent should read the requirement from the live system rather than hardcoding it, because the requirement can change when the environment is updated. If the agent cannot confirm it has sufficient resources before acting, it will fail partway through an operation with no clean recovery path.\n* **Concurrent state changes.** When an agent reads state and then acts on it, other actors can modify that state between the read and the write. This is true in any multi-tenant environment. The agent needs to handle the case where its action is rejected because the state no longer matches its assumptions. Retrying the read and write in a tight loop is often sufficient, but for time-sensitive operations the agent needs a fallback that produces a legal action based on the current state rather than the stale state.\n* **Event reliability.** Event-driven notification is low-latency but unreliable in any distributed system \u2014 connections drop, events fire before finalization, events fire multiple times. Polling is reliable but adds latency. Using neither means the agent misses state changes. Using only events causes missed notifications when the connection drops. Using only polling causes unnecessary delay. The hybrid approach runs an immediate poll on entry to catch notifications that arrived before the watcher started, subscribes to events for low-latency notification, and continues polling in a loop to catch everything the events missed.\n* **Identity and signing.** The agent's identity \u2014 whether a blockchain wallet, an API key, or a service account \u2014 should be derived once at startup and reused for the lifetime of the process. Re-deriving identity on every operation is wasteful and introduces opportunities for inconsistent signing state. The key store is a singleton that derives the identity from the private key once and reuses it for all subsequent operations.\nThese are not architecturally interesting problems. They are the operational details that break running agents, and every one of them had to be solved before the agent could play through a full session. The model is the most visible component of the system, but the infrastructure around it is what determines whether the agent survives in production.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Running It"
        },
        {
          "role": "assistant",
          "content": "### Running It\nThe agent runs as a standalone process with environment variables for configuration:\n```bash\nPRIVATE_KEY=0x... LLM_API_KEY=sk-... STRATEGY=wolf bun run start\n```\nOr Docker with one private key per container:\n```yaml\nservices:\n  agent:\n    build: .\n    environment:\n      PRIVATE_KEY: \"${PRIVATE_KEY}\"\n      LLM_API_KEY: \"${LLM_API_KEY}\"\n      STRATEGY: \"${STRATEGY:-wolf}\"\n      MEMORY_BACKEND: \"${MEMORY_BACKEND:-memory}\"\n    restart: unless-stopped\n```\nThe agent discovers the factory contract, joins or creates a table, funds itself from the faucet, and starts playing. It handles restarts, gas exhaustion, model failures, stale state, and race conditions between reading and writing.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: What I Learned"
        },
        {
          "role": "assistant",
          "content": "### What I Learned\n* **The model is the least reliable component in the system.** The LLM produces invalid output 10-30% of the time depending on provider and model, and it fails in unpredictable ways \u2014 returning prose instead of tool calls, using invalid action names, inventing parameter values that do not match the schema, or returning nothing at all. Designing for model failure at every layer is not pessimism; it is the minimum bar for a production agent loop.\n* **A deterministic fallback policy is more important than prompt engineering.** No amount of prompt tuning will make the model 100% reliable. A 200-line deterministic engine that runs in microseconds and always produces a legal action is worth more than weeks of prompt iteration. The LLM gets the first vote, but the runtime must have the final say.\n* **The three-layer decision architecture is the key pattern.** The LLM provides creativity and adaptation. The deterministic policy provides speed and reliability. The last resort provides guaranteed output. Each layer catches the failures of the layer above it, and each layer operates at a different speed and cost profile so they complement rather than duplicate each other.\n* **Session recovery must verify against live state, not trust persisted state.** Persisting the agent's position and restoring it on boot is necessary but not sufficient. The agent must call the live system to verify that the persisted state is still valid, because the world may have changed while the agent was offline. Many agent implementations skip this verification and get stuck operating on stale assumptions.\n* **Event-driven notification and polling must be used together.** Neither approach is reliable enough alone. Events are low-latency but drop under network issues. Polling is reliable but adds latency and misses short-lived state transitions. The hybrid approach of polling on entry, subscribing to events, and continuing to poll in a catch-up loop handles the failure modes of both strategies.\n* **The logging infrastructure is the future training pipeline.** Every action the agent takes is logged with its reasoning and the full state at decision time. This creates an audit trail for debugging today and a labeled dataset for fine-tuning tomorrow. The self-learning loop that uses this data to improve the model over time is the next evolution of the system.\n* **Strategic consistency is a design choice with real tradeoffs.** The fallback policy uses the same aggression and tightness parameters as the LLM prompt, so a bull that cannot get a valid LLM response still raises rather than folding passively. This means the agent sometimes loses money it could have saved, but the agent's long-term behavior stays predictable and measurable against its design goals. The opposite choice \u2014 a conservative fallback that minimizes downside risk \u2014 is equally valid for different contexts. A payment agent should not default to sending more money when uncertain, and a content moderation agent should not default to approving content when confused. The right answer depends on whether the cost of acting against strategy is higher or lower than the cost of failing to act.\nAgent loops and agent frameworks are severely under-documented, and the actual design of building production agents is still very much up for grabs. There are no canonical patterns for handling model failures in a loop, no established wisdom around fallback architectures or session recovery, and most of what exists is buried in blog posts or locked inside private codebases. The goal of this post was to add one more data point \u2014 and to make the case that agent loops are not chat loops, and building them requires treating model failure as a first-class design constraint rather than an edge case.\nThe full source is at github.com/thegreataxios/confidential-poker, with the agent code under `agents/langchain/`. If you are building agent loops that need to handle real-world failure modes, I am working on this daily and happy to talk through the patterns."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples."
        },
        {
          "role": "assistant",
          "content": "Explore who documentation is actually built for in the agentic era, some critical items of AI-first documentation, and a real world exploration of updating the SKALE Network documentation to Mintlify -- the intelligence documentation platform."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Intro to SKALE v3 Docs"
        },
        {
          "role": "assistant",
          "content": "### Intro to SKALE v3 Docs\nThe SKALE v2 documentation was built with https://astro.build and https://starlight.astro.build and represented a signifant structural shift from the SKALE v1 documentation which used Antora for multi-repo static site design. When I led the v2 update there was a lot of discussion around what to use for documentation. We almost went with https://vocs.dev from the wevm team, but chose to go with Astro instead due to the belief that it would be easier to maintain and more accessible to contributors.\nThat turned out to be a mistake and over the course of the last year or so it become clear that with the rapid adoption of AI tools -- especially for coding -- the need for an AI-first documentation platform became more and more apparent.\nA documentation portal built for AI should in my opinion have two key things:\n1. llms.txt and llms-full.txt file that are generated from the documentation and provider clear guidance to LLMs on how to navigate and consume the documentation about the product or service for agents\n2. Open in XYZ buttons (i.e Open in ChatGPT) which is for humans\nFrom a design perspective, there are two key things the documentation portal take into account fror design:\n1. It should be designed in a way where pages are generally written for humans, but contain extra notes and context that agents will benefit from on edge cases\n2. Content should be separated into sections and pages clearly named, laid out, and as concise as possible to avoid overwhelming an LLM with too much information AND to reduce the amount of money spent on unused context\n:::note\nBefore continuing, we must give credit where credit is due. An incredible effort from Manuel Barbas, Lead Implementation Engineer at SKALE, who led the effort on the cookbook section, made massive contributions to the v3 push with a series of amazing PRs, and helped from Day 0 on the organization of the v3 planning.\n:::"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Why We Migrated to Mintlify"
        },
        {
          "role": "assistant",
          "content": "### Why We Migrated to Mintlify\nThe migration to Mintlify wasn't just about a prettier interface -- although Mintlify is 10x cleaner from a UI in my opinion compared to Starlight -- but it was really driven by two key items. The first was the need to lean into the agentic world that is becoming more and more important. The SKALE v2 Docs did have a small llms.txt file but it was minimal and missing significant coverage. Additionally, it lacked contributions for an open network due to it being built on open-source tools but highly bespoke.\nThe switch to Mintlify allows SKALE to join thousands of other projects and companies from small to enterprise using Mintlify; making it even easier for contributors to get started and contribute.\nAdditionally, Mintlify not only helps the SKALE Documentation become AI ready, but it also provides an MCP server and AI-ready documentation for agentic coding tools making the above contributions even simpler.\n**Before:** The Astro/Starlight setup had basic AI readiness, but it was fragmented\n**After:** Mintlify provides industry-standard AI tooling with better llms.txt support\nThe old docs had a basic llms.txt at https://docs-skale-space.vercel.app/llms.txt that linked to a smaller and larger one, but the new setup at https://docs.skale.space/llms.txt better matches the industry standards."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Section Reorganization: Separating Concepts from Cookbook"
        },
        {
          "role": "assistant",
          "content": "### Section Reorganization: Separating Concepts from Cookbook\nOne of the biggest feedback items from developers was that SKALE's documentation mixed conceptual information with practical implementation details. This made it hard for developers to quickly jump to the \"about\" a topic or the \"how to\" of a topic.\nThe new structure explicitly separates:\n* **Concepts**: Understanding SKALE Network fundamentals\n* **Developers**: Developer-specific basics\n* **Cookbook**: Recipe-style examples for the EVM, the agentic economy, and SKALE specifics\nThis reorganization came directly from developer feedback and AI tooling needs. When an agent is trying to understand SKALE Expand or implement gasless transactions into an application, it shouldn't have to wade through unnecessary context or information."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Introducing SKALE Expand"
        },
        {
          "role": "assistant",
          "content": "### Introducing SKALE Expand\nThe new docs prominently feature SKALE Expand, which I think represents a fundamental shift in how we think about blockchain deployments. As I explored in The Gasless Design Behind x402, SKALE Expand allows SKALE's infinitley horizontal scalability and newer privacy features to be deployed within any EVM ecosystem.\nThis means developers can get SKALE's uniuqe value props like private transactions, zero gas fees, and instant finality direclty within Base or other EVM ecosystems. The docs now include dedicated sections explaining how to leverage this for cross-chain applications."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: BITE Protocol: Integrated Privacy and Encryption for the EVM"
        },
        {
          "role": "assistant",
          "content": "### BITE Protocol: Integrated Privacy and Encryption for the EVM\nThe documentation now includes comprehensive coverage of BITE Protocol, which I introduced in Proof of Encryption in the Cloud. BITE, which stands for Blockchain Integrated Threshold Encryption, is the basis for the private and encrypted exeuction capabilities being integrated into the SKALE Network."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Chain Types and Developer Experience Updates"
        },
        {
          "role": "assistant",
          "content": "### Chain Types and Developer Experience Updates\nThe new documentation introduces clear categorization of SKALE chain types:\n* **Appchains**: Dedicated blockchains for single applications\n* **Credit Chains**: Chains focused on DeFi and financial applications\n* **Gasless Chains**: Zero-fee environments for micropayments and agentic systems\nThis clarity helps developers choose the right infrastructure for their use case. Combined with the streamlined \"Go Live\" page and updated SKALE Base guides, new developers can get started much faster."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Cookbook Additions for the Agentic Era"
        },
        {
          "role": "assistant",
          "content": "### Cookbook Additions for the Agentic Era\nThe cookbook section now includes recipes specifically for AI agents and the broader machine economy:\n* **x402 Examples**: How to implement the HTTP 402 payment protocol on SKALE\n* **Privacy Recipes**: Using BITE Protocol for confidential transactions\n* **Native Features**: Leveraging SKALE's built-in RNG and gasless transactions\nThese additions reflect the growing importance of agentic systems. As I wrote in The Role of Pay-Per-Tool in an Agentic World, agents need practical, implementable patterns for economic interactions. With SKALE's recent positioning changes around the agentic economy and bringing more agents onchain, it's important to have a clear path for developers to get started."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: List of changes"
        },
        {
          "role": "assistant",
          "content": "### List of changes\n* Migrated from Astro/Starlight to Mintlify, the industry standard for tech startups, to improve AI readiness and make contributions easier for developers\n* Enhanced AI readiness with better llms.txt support for machine consumption\n* Reorganized sections with a clear split between concepts and developers, plus an explicit cookbook section\n* Separated developer knowledge from cookbook recipes based on community feedback and AI tooling requirements\n* Brought back sections covering the SKL token, staking, and introduced new areas like SKALE Expand\n* Restored the SKL token page and SKL staking page for better token economics coverage\n* Updated the SKALE Base integration page with clearer information\n* Improved the SKALE Ethereum chains documentation with more clarity\n* Streamlined the developer onboarding flow with a cleaner \"Go Live\" page\n* Added a new concepts section covering SKALE Expand and BITE Protocol fundamentals\n* Created a dedicated \"Integrate SKALE\" section for developers looking to build on the network\n* Added comprehensive chain type documentation covering Appchains, Credit Chains, and gasless chains\n* Integrated full BITE Protocol documentation for privacy features\n* Expanded the cookbook with new deployment guides, privacy recipes, x402 payment examples, AI agent patterns, and native features like gasless transactions and random number generation\n* Updated all existing code examples to reflect current best practices"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Conclusion"
        },
        {
          "role": "assistant",
          "content": "### Conclusion\nI think this documentation update represents SKALE's commitment to both the machine economy and the agentic era. By migrating to Mintlify, restructuring for AI accessibility, and adding comprehensive coverage of emerging technologies and initiatives like BITE Protocol and SKALE Expand, the docs now serve both human developers, coding agents, autonomous agents, and LLM platforms.\nThe focus on practical implementation, clear separation of concepts from recipes, and recognition that the ecosystem extends beyond official documentation shows a mature understanding of developer needs. As agentic systems become more prevalent, documentation like this will be crucial for enabling the next generation of blockchain applications.\nHave thoughts on the docs or want to contribute? Join the SKALE Discord or reach out. I'm always interested in feedback on how I can better serve the ecosystem."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers."
        },
        {
          "role": "assistant",
          "content": "This comprehensive overview showcases Eidolon's modular Unity SDK ecosystem designed to accelerate game development through specialized, lightweight packages that handle everything from OS device data access and physics calculations to Web3 blockchain integration and networking. Each SDK integrates seamlessly with zero conflicts, providing developers with powerful tools for randomization, timer management, controller input handling, and WalletConnect support while enabling faster development cycles for both traditional Web2 and emerging Web3 gaming experiences.\n![](https://miro.medium.com/v2/resize\\:fit:1400/1*RTBMMqrRkmi0xOmtQwDmcg.jpeg)\nWelcome to **Eidolon**! If you are new, the TLDR is that Eidolon is a game development tooling company here to help developers build games better and faster. How do we do this?\n1. Top Tier SDKs \u2014 with a focus on Unity but some web based and mobile tools in Alpha.\n2. Top Tier Support \u2014 we want to help you ship. It's ok to ask for help.\n3. Web2 + Web3 Experience \u2014 that's right. We aren't afraid to explore and help developers even in unproven areas."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Eidolon.OS"
        },
        {
          "role": "assistant",
          "content": "### Eidolon.OS\n**Eidolon.OS**\u00a0streamlines access to device-specific data, making Unity development more dynamic and responsive to user environments. With this package, developers can effortlessly retrieve system information like OS type, battery level, memory size, and network status. By centralizing access to device data, Eidolon.OS saves developers time from coding platform-specific logic and enhances app performance by intelligently adapting to user devices.\n**Code Example**\n```csharp\nstring deviceModel = OS.GetDeviceModel();\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Eidolon.Newton2D/3D"
        },
        {
          "role": "assistant",
          "content": "### Eidolon.Newton2D/3D\n**Eidolon.Newton2D**\u00a0and\u00a0**Newton3D**\u00a0are physics packages for Unity, optimized for managing 2D and 3D physics interactions. Both provide easy-to-use methods for applying forces, managing constraints, and controlling motion damping. By focusing on common physics tasks, these tools reduce the need for repetitive code and help developers create engaging and realistic environments in games and simulations.\n**Code Example**\n```csharp\n// 2D Physics  \nNewton2D.ApplyForce(rigidbody, forceDirection, forceMagnitude);  \n// 3D Physics  \nNewton3D.ApplyForce(rigidbody, force);\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Eidolon.Random"
        },
        {
          "role": "assistant",
          "content": "### Eidolon.Random\n**Eidolon.Random**\u00a0simplifies adding randomness to Unity projects. With versatile functions for generating random values \u2014 booleans, colors, vectors, and more \u2014 it covers all aspects of randomization, helping developers add unpredictability to gameplay and simulate natural variations.\n**Code Example**\n```csharp\nColor randomColor = RandomUtil.RandomColor();\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Eidolon.Timer"
        },
        {
          "role": "assistant",
          "content": "### Eidolon.Timer\n**Eidolon.Timer**\u00a0is a flexible timer solution, perfect for games needing precise time management. Offering start, stop, pause, and completion callbacks, it\u2019s a ready-to-use package that replaces complex timer code, making event-based programming simpler.\n**Code Example**\n```csharp\nfloat duration = 10f;  \nGameTimer timer = new GameTimer(duration, OnTimerComplete);  \ntimer.Start();\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Eidolon.Controller"
        },
        {
          "role": "assistant",
          "content": "### Eidolon.Controller\n**Eidolon.Controller**\u00a0standardizes controller input handling, accommodating popular controllers like PlayStation and Xbox. This package allows developers to detect connected controllers, initialize button mappings, and easily retrieve input data, making cross-platform compatibility simpler.\n```csharp\nbool controllerDetected = Controller.DetectConnectedController();\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Eidolon.Web3"
        },
        {
          "role": "assistant",
          "content": "### Eidolon.Web3\n**Eidolon.Web3**\u00a0is an all-encompassing Ethereum compatible SDK for blockchain integration in Unity, abstracting complex operations like wallet interactions, asset management, and smart contract executions. Tailored for Unity, it\u2019s user-friendly with comprehensive documentation, helping developers unlock new possibilities in game economics and ownership."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Eidolon.WalletConnect"
        },
        {
          "role": "assistant",
          "content": "### Eidolon.WalletConnect\n**Eidolon.WalletConnect**\u00a0enables blockchain-based interactions within Unity, allowing players to connect mobile wallets like MetaMask directly to the game. With QR-based connections and built-in transaction handling, it\u2019s a straightforward solution for integrating blockchain assets and dApps into game experiences.\n**Code Example**\n```csharp\nprivate void Awake()  \n{  \n// Instantiate our wallet using a default configuration that will use the chain we set in our project setup.  \nwallet = new WalletConnectWallet();  \n}  \nprivate async void Start()  \n{  \n// Initialize our wallet and generate the QR Code data  \nstring rawQrCodeData = await wallet.Initialize();  \n// Generate and show the QR Code Texture  \nqrCode.texture = await wallet.GenerateQRCodeImage(rawQrCodeData);  \n// Wait for the player to connect and assign their public address to a variable  \nstring account = await wallet.AwaitAuthentication();  \n// Optional - Set the account to PlayerPrefs  \nPlayerPrefs.SetString(\"Account\", account);  \n// Display the connected account  \nDebug.Log(\"Connected Account: \" + PlayerPrefs.GetString(\"Account\"));  \n}\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Eidolon.Networking"
        },
        {
          "role": "assistant",
          "content": "### Eidolon.Networking\n**Eidolon.Networking**\u00a0simplifies HTTP requests within Unity. Supporting GET, POST, PUT, and DELETE operations, along with custom headers and error handling, it minimizes setup complexity, allowing developers to efficiently incorporate web-based features.\n**Code Example**\n```csharp\nstring url = \"https://api.example.com/data\";  \nEidolonRequest.Get(url, headers, response => { Debug.Log($\"Response: {response}\"); });\n```\nEach Eidolon package is designed to save development time, provide focused functionality, and integrate seamlessly with Unity, making them essential tools for efficient game development in the blockchain and web-enabled space.\nAdditionally, while every Eidolon SDK is designed to be minimal to maintain maximum impact with the smallest footprint; the suite is also 100% modular with every package being able to work in the same codebase with zero conflicts."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "When you give an AI model access to tools \u2014 a weather API, a database query, a file system \u2014 you have to tell it what tools are available and how to use them. The standard approach is JSON Schema. For each tool, you define its name, its parameters, their types, which ones are required, and what values are valid. Every major SDK defaults to this.\nThis is not just a convention. The industry invests heavily in making JSON Schema tool calling work. Anthropic includes tool definitions in RL safety training to improve agentic behavior. Researchers are building benchmarks like SchemaBench \u2014 40,000 JSON schemas \u2014 and proposing reinforcement learning pipelines to teach models to generate valid structured output, because even frontier models struggle with schema correctness. The assumption baked into all of this is that the model needs more exposure to schemas, more training on structured output, more guardrails.\nI have been experimenting with the opposite: stripping the JSON Schema out entirely and describing tools in plain English. On complex multi-step tasks, models performed better without the schema. The benchmark is small and the findings are early, but the pattern was consistent enough to write up."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Imagine you are a chef"
        },
        {
          "role": "assistant",
          "content": "### Imagine you are a chef\nThe standard approach \u2014 sending tools as JSON Schema \u2014 is like being handed a cookbook written in legal jargon:\n> Pursuant to Article 3, Section B, the applicant shall: chop(ingredient: VegetableType, method: ChopStyle, thickness: Integer \u2208 \\[1, 10]), boil(liquid: LiquidType, duration: Integer)\nYou have to read the legalese every time before you cook. When you want to chop an onion, you cannot just reach for the knife \u2014 you have to fill out a form:\n```json\n{\"type\": \"tool_use\", \"name\": \"chop\", \"input\": {\"ingredient\": \"onion\", \"method\": \"dice\", \"thickness\": 3}}\n```\nNow imagine instead that someone just tells you, in plain English:\n> You have a knife. Use it like: `chop onion dice`\\\n> You have a pot. Use it like: `boil water 10min`\nAnd when cooking, you naturally say:\n> I'll chop the onion first. `<call>chop onion dice 3</call>`\\\n> Done. Now I'll boil water. `<call>boil water 10</call>`\nNo legal jargon. No forms. You just cook."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Why it works"
        },
        {
          "role": "assistant",
          "content": "### Why it works\nThe legalese was never helping the chef. It was helping the kitchen management system \u2014 the API \u2014 validate that recipes are formatted correctly. But the chef already knows how to chop an onion. The legalese only distracts them.\nSame dynamic with the model. JSON Schema was designed for developers \u2014 it validates types, enums, required fields. The model may not benefit from it in the same way. The natural language descriptions already convey what tools expect. The JSON Schema may just consume attention the model could use for reasoning."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Simple recipes, complex recipes"
        },
        {
          "role": "assistant",
          "content": "### Simple recipes, complex recipes\n#### What I mean by difficulty\nEasy \u2014 difficulty 1 through 4 \u2014 is a single tool call with straightforward parameters. \"Get the weather in Austin\" is one call, one parameter, no dependencies.\nMedium \u2014 5 through 7 \u2014 chains three to five calls where the output of one feeds into the next. \"Get the weather in three cities, find the hottest one, and log the result\" requires sequential calls with the model tracking state between them.\nHard \u2014 8 through 10 \u2014 involves five or more coordinated calls with branching logic. Think multi-step research workflows, or agents that need to fetch, transform, validate, and report.\n#### The benchmark\nTo test whether the compact format actually helped, I built a small benchmark. Eleven prompts, three modes each, across Claude Haiku 4.5 and Claude Sonnet 4.6, using `anthropic-compact-tools`. Tasks ranged from single-call trivia to multi-step chained workflows. Sixty-six total runs.\n| Metric                     | Native (tools in API) | Compact (stripTools) | Change                  |\n| -------------------------- | --------------------- | -------------------- | ----------------------- |\n| Sonnet accuracy            | 5/11 (45%)            | 11/11 (100%)         | +55 pp / +120% relative |\n| Haiku accuracy             | 5/11 (45%)            | 8/11 (73%)           | +27 pp / +60% relative  |\n| Input tokens (both models) | \\~9,100               | \\~3,600              | -61%                    |\n| Haiku cost per 11 calls    | $0.0158               | $0.0130              | -18%                    |\nBroken down by task difficulty:\n| Difficulty   | Native (Sonnet) | Compact (Sonnet) | Native (Haiku) | Compact (Haiku) |\n| ------------ | :-------------: | :--------------: | :------------: | :-------------: |\n| Easy (0-4)   |       5/5       |        5/5       |       5/5      |       5/5       |\n| Medium (5-7) |       0/3       |        3/3       |       0/3      |       2/3       |\n| Hard (8-10)  |       0/3       |        3/3       |       0/3      |       1/3       |\nOn easy tasks, both formats worked. At medium difficulty and above, the legalese approach went zero-for-six on both models \u2014 not degraded, just complete failure. The plain-English format handled five of six medium tasks and four of six hard tasks.\n#### Back to the chef\nPicture a simple recipe \u2014 boiling an egg. One tool (a pot), one parameter (how long). No dependencies, no sequencing. The legalese form is annoying but manageable. There is room for it.\nNow picture a complex recipe \u2014 preparing a three-course meal. The chef needs to chop vegetables, boil water, sear protein, check temperatures, and coordinate timing so everything finishes together. With legalese, half the brainpower goes to the forms and the food burns. Without it, the chef just cooks:\n> I will start with the vegetables. `<call>chop onion dice 3</call>` Done. Now the water needs to go on first since it takes longest. `<call>boil water 12</call>` While that heats up, let me season the steak. `<call>season steak salt pepper garlic</call>`\nA few mechanisms seem to be at play here, and I suspect they compound.\n**JSON Schema consumes attention budget, not just token budget.** The model has to parse schema definitions, extract parameter names and types, hold constraints in working memory, and simultaneously reason about the task. On simple tasks there is enough spare capacity. On complex tasks the schema parsing crowds out reasoning. The model does not run out of tokens \u2014 it runs out of attention.\n**Serial reasoning bottleneck.** With JSON Schema, all tool calls must be output at the end of the response, before any execute. The model plans everything upfront with no chance to adjust mid-stream. The compact format lets calls appear inline as the model reasons, creating chain-of-thought for function calling.\n**The two-language problem.** Switching between natural language and JSON output appears to add friction \u2014 the model has to shift modes mid-generation. Compact format keeps everything in one mode.\n**Distribution shift failure.** The default `tool_use` JSON format works reliably on simple tool calls and collapses on complex multi-step tasks. This pattern \u2014 flawless performance on simple tasks, sudden failure at higher complexity \u2014 looks like a generalization boundary. Anthropic documented a similar shape in *Teaching Claude Why*: their safety training produced strong results on in-distribution evals but did not hold up when the scenario shifted to agentic tool use. The more effective approach was teaching the principles behind the behavior rather than relying on narrow scenario-specific training.\nThe compact format may avoid a similar pitfall. It does not require the model to execute a specific output routine (a JSON `tool_use` block). It gives the model a lightweight pattern \u2014 `<call>name args</call>` \u2014 and lets the model decide when and how to use it during generation. The accuracy cliff did not appear in the compact format, which suggests the rigid output structure of JSON Schema was part of the problem, not the solution."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Would this work at scale?"
        },
        {
          "role": "assistant",
          "content": "### Would this work at scale?\nYes, even better. The benefit compounds.\n**More tools = bigger savings.** The JSON Schema for a typical 20-tool set can run 800+ tokens per request (more for verbose schemas). The compact format sends tool definitions once in the system message \u2014 roughly 200 tokens. The bigger the tool set, the more overhead you remove.\n**Longer conversations = compound savings.** History rewriting converts past `tool_use` blocks to compact format, compressing every turn's tool calls. Over 10 turns, the savings multiply.\n**Complex schemas are handled.** Tools with deep JSON args use dot-path notation \u2014 `profile.address.city=Austin` \u2014 or a JSON inline fallback like `<call>submit_order {\"items\":[{\"id\":1,\"qty\":3}],\"shipping\":{\"address\":\"...\"}}</call>`. The parser detects which format the model used either way.\n**The accuracy cliff widens.** The impact on production agent systems compounds because the hardest tasks are the ones that matter most. If the compact format continues to handle complex multi-step tasks where JSON Schema fails, the savings in debugging time alone justify the switch."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: What I have not tested"
        },
        {
          "role": "assistant",
          "content": "### What I have not tested\n* **Model forgets tools exist.** The system message lists them, which usually works, but the model could return text with no calls. In my small benchmark this did not happen, but I would not rely on that holding at scale without a retry loop.\n* **Large tool sets (50+).** The system message gets long. I have not found the ceiling, and I do not know where the compact format starts degrading relative to native.\n* **Binary or multipart outputs.** The text format does not support these. Untested.\n* **Extended thinking mode.** Untested. Extended thinking might help native mode close the gap, or it might conflict with the compact format. I do not know yet.\n* **Deeply nested schemas (5+ levels).** Dot-path flattening gets awkward. I have not tested whether the model handles deeply nested args well in compact format.\n* **`tool_choice` enforcement.** If you rely on `any` or `tool` modes to force tool calls, those require the `tools` parameter to be present in the API call. Compact format replaces `tools` with system message instructions, so `tool_choice` is not directly compatible."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Bottom line"
        },
        {
          "role": "assistant",
          "content": "### Bottom line\nThe compact format is like removing training wheels from a bike. For simple rides, both setups work. For complex terrain, the training wheels actively prevent maneuvering. The more complex the terrain, the worse they get.\nThe accuracy cliff I measured was real and model-independent \u2014 both Haiku and Sonnet collapsed on multi-step tasks under JSON Schema and recovered under the compact format. If this generalizes, the implication is uncomfortable: the tool-calling format most of the industry uses by default may be actively hurting accuracy on the tasks that matter most.\n```sh\nnpm install anthropic-compact-tools\n```\nThe full source, benchmark runner, and all results are at github.com/thegreataxios/anthropic-compact-tools. Fork the benchmark, swap in your own tools and models, and see where your accuracy cliff lives."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Methodology"
        },
        {
          "role": "assistant",
          "content": "### Methodology\n* 66 calls across two models (Claude Haiku 4.5 and Claude Sonnet 4.6)\n* 11 prompts in 3 modes each: native (tools in API), compact (stripTools), and a control\n* Tasks ranged from single-call trivia to multi-step chained workflows\n* Difficulty scored on a 0\u201310 scale based on number of calls, dependencies, and branching logic\nThis is an early experiment. The absolute numbers are directional, not definitive. Your results will vary by model, tool set, and task complexity. Run the benchmark on your own workload before drawing conclusions.\nThis post is a follow-up to A Compact Flat Format for LLM Tool Calling, which introduced the compact format and parser. Here I benchmark whether the approach actually works under pressure while applying it directly to Anthropic's models and SDK.\n***\n1. anthropic-compact-tools repository (benchmark code, parser, stream interceptor). https://github.com/thegreataxios/anthropic-compact-tools\n2. Anthropic, \"Teaching Claude Why\" (RL safety training research, May 2026). https://www.anthropic.com/research/teaching-claude-why\n3. SchemaBench: 40,000 JSON Schema benchmark. arXiv 2502.18878. https://arxiv.org/abs/2502.18878\n4. anthropic-compact-tools on npm. https://www.npmjs.com/package/anthropic-compact-tools"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: MCP Feedback No. 1"
        },
        {
          "role": "assistant",
          "content": "### MCP Feedback No. 1\nThe following are personal opinions and perspectives on the Model Context Protocol (MCP) and how teams building developer tooling\u2014both for pure AI and agentic commerce (i.e. x402)\u2014should be thinking about them. If you have any feedback or feel I missed something, please let me know.\n* I think the Vercel and xmcp docs are overall really good for those trying to build an MCP server.\n* The base of MCP is technically very simple, but when you start to build, there are actually a number of pieces that need to be learned and considered. I think good documentation and examples are critical to the success of having developers build on top of your libraries. Specifically, where possible, you should provide examples **with and without** different pieces of functionality. The most clear-cut one for me is transports: `stdio` and `Streamable HTTP`. Go ask the average dev what SSE stands for and you'll understand why this is relevant.\n* More broadly on documentation and examples: for those looking to extend MCP into something explicit (i.e. x402-enabled MCPs), it's important to provide as many clean and simple examples as possible (e.g. Express, Hono, Next.js, etc.), instead of just one. I also think showing an E2E example (even if separately in a blog) is really helpful. Everyone pushing for MCP adoption\u2014static or agentic\u2014should have at least one E2E example: start, add tool, test, deploy to XYZ provider.\n* Props to the larger enterprises\u2014they tend to be really good at having their documentation match their examples in GitHub. I think this is key to having developers build on top of more complex integrations. If you are building examples in docs, match them with examples in GitHub.\n* I think this is currently stemming from `@modelcontextprotocol/sdk`, but the use of Zod v3 everywhere is a bit annoying when all the docs just say `npm add zod`. This directly causes friction and either errors during usage or causes the LSP to go haywire. The recommendation is to specify `npm add zod@3` in your documentation/tutorials. See xmcp, which calls this out properly, as well as MCPay.\n* The core design of an MCP should be vendor-agnostic. I think Cloudflare currently breaks this with their MCP implementation, which has an entirely different design than everyone else. While not bad, it does make it more difficult for me, as I\u2019m uncertain how portable their design is. I also find their \u201cAgentMCP\u201d verbiage a bit confusing, as not all MCPs are designed to be agents.\n* Authorization and access controls are mentioned (although a bit buried) in the official MCP documentation. More docs and examples on securing MCPs are needed for as many different authentication schemes as possible\u2014including new and open protocols. How does this play in with trustless agents?\n* Maybe an unfair statement since many MCP servers have been created, but I find that the vast majority of MCPs exist to either wrap APIs or inference endpoints. Personally, I just want to see more static content and deterministic functionality. I have minimal proof points, and most stem from my own experiences training small language models, but it seems like there\u2019s an opportunity for static MCPs to enhance SLMs trained on specific use cases.\n* The ability to call tools consistently is something that I think is overlooked. When using top language models, it tends not to be as prominent, but there is value in having more consistent tool calling for people building agents using specialized models.\n* On the previous point\u2014could this be easily solved through training a LoRA adapter or similar? I.e. should there be adapters focused on tool calling to enhance existing or older models that are cheaper or better at something specific? (I know, crazy to call an old model better.)\n* Input and output schemas seem to be semi-standardized. It would be nice to see that become more consistent across MCPs. I think this also helps models become more consistent at calling tools.\n* More clarity (maybe through exploration) on using fewer tools. MCP servers with a lot of tools consume a lot of context. Claude Skills has proven to be a strong alternative and is highly praised for removing this.\n* More guidance for new developers on where and when MCP is actually useful or needed. MCP has been touted as a \u201cone-size-fits-all\u201d solution for developers coming into agentic systems. We need a better way to communicate what pieces should be used where in these growing systems."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: My Personal Requests & Ideal Experience"
        },
        {
          "role": "assistant",
          "content": "### My Personal Requests & Ideal Experience\n* More clarity on how to use MCPs from anyone touting MCP libraries.\n* If you are offering MCPs, make it easy for me to pay you to host them for me.\n* If providing agentic coding tools, provide examples of how to consume the MCP in all popular tools (not just Cursor).\n* More information (or point me in the right direction) for better authentication schemes, guidance, and security-related resources for MCPs.\n* One or two more frameworks to push and compete with xmcp and Vercel. More competition drives innovation. Preferably if one of these can just fully abstract all of the \"MCP\" code away and just let me focus on the logic that would be lovely. (Happy to provide further guidance, but this is where the magic SaaS is at in my opionion)\n* A cloud platform built for hosting MCPs\u2014handling sandbox execution, AI Gateway, authentication (without OAuth, please), x402 integration, etc. I\u2019m a big believer in a SaaS model for MCPs. It\u2019s unrealistic to expect most developers to run their own servers. Also a great opportunity to enable fractional resourcing that hot-swaps scoped API keys for different customers. (High risk, high reward?)\n* Payment management and tracking software for MCPs. I think there\u2019s a really interesting opportunity with x402 for someone to build middleware that handles tracking, spending, and analytics for the callers (could be cloud or local). For example: my agent calls an MCP server N times per day and spends X via Y.\n* Make it easier or standardized to define whether the MPC is a \"per-tool\" or \"aggregated\" toolset. For agents, this would ideally allow them to determine if they should call an MCP server that has \"math\\_add\" \"math\\_subtract\" or an MCP that has \"search\\_tool\" -> \"add two numbers, a + b\". More general purpose models seem like they are able to better benfit from aggregated toolsets (tbd) while smaller specialized models may be better for train adapters on specific tools.\n* If integrating with x402, give me a set of 2-3 defaults: Base, SKALE, and Solana. I don't want to have to keep specifying the same thing over and over again. I should be able to but just default me to the most common chains + the best technically.\n* Don't force me to specify bypass methods. Middleware should handle that for me since the bypass methods are primarily standardized at this point. I should be able to change WHO can bypass based on IP/secrets/JWT/etc."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Conclusion"
        },
        {
          "role": "assistant",
          "content": "### Conclusion\nThis is very much my first ramble on something I\u2019m still learning about myself. I don\u2019t think anyone is doing anything wrong\u2014these are all just my opinions and perspectives. If you agree or disagree, feel free to reach out to collaborate or discuss!"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers."
        },
        {
          "role": "assistant",
          "content": "AI systems have moved past the era of a single LLM doing everything and now represent a complex ecosystem of context, memory, prompting, tools, and skills. Multi-agent systems are increasingly common in production, but they are more often found inside private systems. Why? Sharing information between unknown agents is a major challenge. Protocols like Google's Agent-2-Agent (A2A) use structured JSON messages to communicate, but they do not solve the problem of variable memory across open systems and swarms as tasks grow more complex.\nThis raises a few critical questions that, if answered, could unlock key blockers to understanding the machine economy:\n> 1. How does a shared memory layer that is fair to everyone actually work?\n> 2. What is the best way to share information between agents?\n> 3. Why is immutable storage NOT always the answer?\n> 4. Who pays for the storage in a public, shared system?\nIf agents are to collaborate at scale and the machine economy is to become truly viable, agents need a memory layer that allows information to be stored and shared between public and private systems without relying on a central authority.\nMemory is a critical component of the machine economy. This article explores the challenges and potential solutions for building a shared memory layer for agents."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: A Brief Note on Public Memory"
        },
        {
          "role": "assistant",
          "content": "### A Brief Note on Public Memory\nNot all memory should be public. Commercial confidentiality is critical for many people and businesses across their daily operations.\nI am not proposing that memories generated by private LLMs and agentic systems be made public. I am proposing that information critical to the operation of autonomous agents be made public where possible, including capabilities, skills, tools, summaries, reporting, and signals."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: How does a shared memory layer that is fair to everyone actually work?"
        },
        {
          "role": "assistant",
          "content": "### How does a shared memory layer that is fair to everyone actually work?\nA shared memory layer that meets basic fairness criteria should be rigid initially, focusing primarily on ensuring all parties can access the correct memories and verify that they were uploaded by trusted parties.\nnote\nFiles can be immutable, but mutable storage is the default.\n:::"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Who pays for storage in a public, shared system?"
        },
        {
          "role": "assistant",
          "content": "### Who pays for storage in a public, shared system?\nAgents pay for storage, with costs passed to their operators. Operators can then pass on costs to end users if necessary. This mirrors how most software services operate today.\n:::note\nAs a user of Facebook (an agent), Facebook pays cloud storage costs (e.g., SKALE File Storage).\n:::"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Conclusion"
        },
        {
          "role": "assistant",
          "content": "### Conclusion\nBuilding a shared memory layer on SKALE File Storage is straightforward and could enable memory sharing within and across groups of agents. By default, storage is mutable and public, with optional encryption on upload, creating partitioned memory for a growing agentic economy.\nThis is an opinionated perspective. While real-world constraints may limit implementation, exploring how an autonomous economy shares data and information is essential to making it a reality."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: The Problem: Agents Can't Keep Secrets"
        },
        {
          "role": "assistant",
          "content": "### The Problem: Agents Can't Keep Secrets\nYour AI agent just received a user message:\n> \"My name is Alice Smith, email alice@smith.com, phone 555-0123. Please book me a flight to NYC.\"\nIt needs to:\n1. Extract the intent (book a flight)\n2. Call an airline API\n3. Log the interaction for debugging\n4. Maybe hand off to another agent\nHere's the problem: **every step of that pipeline now contains PII.**\nYour logs have it. Your agent-to-agent communication has it. Your downstream APIs have it. One misconfigured log statement, one debug endpoint left open, one prompt injection that exposes context -- and you've got a data breach.\nIn multi-agent systems, **PII isn't a compliance checkbox -- it's a systemic vulnerability.**"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: The Solution: Redact at the Edge"
        },
        {
          "role": "assistant",
          "content": "### The Solution: Redact at the Edge\nprivacy-python-server is a standalone PII redaction API wrapping OpenAI's privacy-filter model. [\\[1\\]](#sources) It does one thing: **sit between your agents and the rest of your infrastructure, stripping out personal information before it spreads.**\n#### How It Works\nPOST text, get back redacted text with typed numbered placeholders:\n```bash\ncurl -X POST http://localhost:8000/redact \\\n  -H \"Authorization: Bearer my-secret-key\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"text\": \"My name is Alice Smith\"}'\n```\nResponse:\n```json\n{\n  \"redacted_text\": \"My name is<PRIVATE_PERSON_1><PRIVATE_PERSON_2>\",\n  \"spans\": [\n    {\n      \"label\": \"PRIVATE_PERSON\",\n      \"id\": 1,\n      \"text\": \" Alice\",\n      \"start\": 10,\n      \"end\": 16,\n      \"score\": 0.9999989867210388\n    },\n    {\n      \"label\": \"PRIVATE_PERSON\",\n      \"id\": 2,\n      \"text\": \" Smith\",\n      \"start\": 16,\n      \"end\": 22,\n      \"score\": 0.9999899864196777\n    }\n  ],\n  \"summary\": {\n    \"total_spans\": 2,\n    \"by_label\": {\n      \"PRIVATE_PERSON\": 2\n    }\n  }\n}\n```\nNotice what happened:\n* **\"Alice Smith\"** becomes **`<PRIVATE_PERSON_1><PRIVATE_PERSON_2>`**\n* You get back the redacted text *and* metadata about what was detected\n* Each span has position, confidence score, and type label\n* The placeholders are typed and numbered, so you can track entities across documents\n#### What It Detects\nThe model catches 8 categories of PII:\n| Type              | Example                      |\n| ----------------- | ---------------------------- |\n| `private_person`  | Names                        |\n| `private_email`   | Email addresses              |\n| `private_phone`   | Phone numbers                |\n| `private_address` | Street addresses             |\n| `private_url`     | URLs with PII                |\n| `private_date`    | Birth dates, sensitive dates |\n| `account_number`  | SSN, account numbers         |\n| `secret`          | Passwords, API keys          |"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Why This Matters for Multi-Agent Systems"
        },
        {
          "role": "assistant",
          "content": "### Why This Matters for Multi-Agent Systems\n#### Defense in Depth\nYou're already doing encryption at rest and TLS in transit. But what about **in-memory**? What about **logs**? What about **agent context windows**?\nRedaction adds a layer that works regardless of where the data flows next. It's like sanitizing inputs at the edge -- except now the \"web\" is your entire agent infrastructure.\n#### Compliance Without Friction\nGDPR, CCPA, HIPAA -- they all say the same thing: **don't store PII unless you need to.**\nMost agent systems store *everything* by default. Conversation history, tool call logs, error traces -- it's all there, unredacted, waiting for an audit.\nWith `privacy-python-server`, you redact before you log. Before you cache. Before you pass to the next agent. Compliance becomes architectural, not procedural.\n#### Agent-to-Agent Hygiene\nIn multi-agent setups, Agent A passes context to Agent B, which calls Tool C, which logs to Service D. That's four hop points where PII can leak.\nPut the redactor at the **inter-agent communication layer**, and every hop gets clean data. Agent B never saw Alice's email. Tool C never received her phone number. Service D only logged placeholders."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Why Use a Server Instead of Importing the Model Directly?"
        },
        {
          "role": "assistant",
          "content": "### Why Use a Server Instead of Importing the Model Directly?\nYou could just `pip install privacy-filter` and call it from your agent code. That works fine for simple cases. But there are real reasons to run it as a separate service:\n#### Sharing Across Many Services\nWhen you have multiple agents, multiple microservices, or multiple teams building on the same infrastructure, you want consistent PII handling. If each service imports the model directly, you get:\n* Multiple copies of the same \\~1.5GB model in memory\n* Inconsistent configuration (different thresholds, different versions)\n* Each service responsible for updating the model independently\n* No centralized logging or monitoring of what's being detected\nWith a shared server, one service handles redaction for everything. Update the model version once, change confidence thresholds in one place, monitor detection rates from a single dashboard.\n#### Resource Constraints: Edge, Serverless, Small Devices\nThis is the bigger reason.\nNot every service that needs PII redaction can afford to download and run a 1.5GB machine learning model. Consider:\n* **Serverless functions** (AWS Lambda, Cloudflare Workers) -- you hit package size limits and cold start times balloon\n* **Edge computing** (Cloudflare Workers, Fastly Compute) -- limited memory, no persistent storage for model caching\n* **Small containers** -- maybe your agent service runs in a resource-constrained environment where adding 1.5GB isn't feasible\n* **Client-side applications** -- browser or mobile apps that can't bundle ML models at all\nIn these cases, offloading redaction to a dedicated server makes sense. Your lightweight service sends text over HTTP, gets back redacted text, and moves on. The heavy lifting happens somewhere with enough resources.\n#### Operational Benefits\nBeyond sharing and resource constraints, running it as a server gives you:\n* **Auth and rate limiting** built-in -- control who can call it and how often\n* **Health checks** -- know when the service is down before your agents start leaking data\n* **Centralized logging** -- see what PII is being detected across your entire system\n* **Independent scaling** -- if redaction becomes a bottleneck, scale this service without touching your agents\n* **Language agnostic** -- your agents can be Python, TypeScript, Go, Rust, whatever. They all speak HTTP."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Architecture"
        },
        {
          "role": "assistant",
          "content": "### Architecture\n```\nUser -> Your Agent Infrastructure -> Airline API\n                |\n         privacy-python-server\n              /redact\n                |\n        Clean Logs\n        Clean Context\n        Clean Handoffs\n```\nThe server is intentionally minimal:\n* **FastAPI** backend (\\~200 lines of Python)\n* **OpenAI privacy-filter** model (runs locally, \\~1.5GB) [\\[1\\]](#sources)\n* **Optional auth** via Bearer tokens\n* **Rate limiting** built-in\n* **CORS support** for browser-based agents\n* **Docker-ready** for deployment\nRun it locally for development:\n```bash\nuv sync\ncp .env.example .env\nDEV_MODE=true uv run python server.py\n```\nOr with Docker:\n```bash\ndocker build -t privacy-filter .\ndocker run -p 8000:8000 --env-file .env privacy-filter\n```\nFirst request downloads the model from HuggingFace (\\~1.5GB), then caches locally. Subsequent requests are fast -- typically under 500ms for short texts."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Integration Patterns"
        },
        {
          "role": "assistant",
          "content": "### Integration Patterns\n#### Logging Middleware\n```python\nasync def log_interaction(text: str):\n    response = httpx.post(\n        \"http://localhost:8000/redact\",\n        json={\"text\": text},\n        headers={\"Authorization\": f\"Bearer {AUTH_KEY}\"}\n    )\n    redacted = response.json()[\"redacted_text\"]\n    logger.info(f\"User message: {redacted}\")\n    return text\n```\n#### Inter-Agent Communication\n```python\nasync def send_to_agent(agent_url: str, context: dict):\n    redacted_context = {}\n    for key, value in context.items():\n        if isinstance(value, str):\n            resp = httpx.post(\n                \"http://localhost:8000/redact\",\n                json={\"text\": value}\n            )\n            redacted_context[key] = resp.json()[\"redacted_text\"]\n        else:\n            redacted_context[key] = value\n    return await httpx.post(agent_url, json=redacted_context)\n```\n#### Pre-Storage Sanitization\n```python\ndef store_conversation(conversation_history: list):\n    sanitized = []\n    for msg in conversation_history:\n        resp = httpx.post(\n            \"http://localhost:8000/redact\",\n            json={\"text\": msg[\"content\"]}\n        )\n        sanitized.append({\n            \"role\": msg[\"role\"],\n            \"content\": resp.json()[\"redacted_text\"],\n            \"pii_summary\": resp.json()[\"summary\"]\n        })\n    db.insert(sanitized)\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: When to Use This (And When Not To)"
        },
        {
          "role": "assistant",
          "content": "### When to Use This (And When Not To)\n**Use `privacy-python-server` when:**\n* You have multiple services that need PII redaction\n* Some of your services run in constrained environments (serverless, edge, small containers)\n* You want centralized control over redaction behavior\n* Your stack is polyglot and you don't want every language binding its own ML model\n* You need operational features like auth, rate limiting, health checks\n**Just \n* You have a single monolithic service\n* Resources aren't a concern\n* You don't need cross-service consistency\n* You want the simplest possible setup with no network hop\nNeither approach is wrong. They're different trade-offs for different situations."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Get Started"
        },
        {
          "role": "assistant",
          "content": "### Get Started\n**Repository:** github.com/thegreataxios/privacy-python-server\n**Quick start:**\n```bash\ngit clone https://github.com/thegreataxios/privacy-python-server.git\ncd privacy-python-server\nuv sync\ncp .env.example .env\nDEV_MODE=true uv run python server.py\n```\n**Test it:**\n```bash\ncurl -X POST http://localhost:8000/redact \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"text\": \"My name is Alice Smith, email alice@smith.com\"}'\n```\nMIT licensed.\n***\n1. OpenAI, \"privacy-filter\" model, HuggingFace. https://huggingface.co/openai/privacy-filter"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "Encrypted transactions protect data in transit. Conditional Transactions (CTXs) allow encrypted data to be executed when a condition is met.\nThis is a new EVM primitive. CTXs enable top-tier automations and workflows: onchain poker, automated liquidations for lending & perps, limit orders on AMMs, sealed-bid auctions, and private agent negotiations where terms stay hidden until reveal time."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: What CTXs Enable"
        },
        {
          "role": "assistant",
          "content": "### What CTXs Enable\nStandard EVM contracts store plaintext. Anyone with a block explorer can read state. CTXs change this \u2014 contracts store encrypted data and trigger decryption via callbacks.\nThe pattern:\n  !CTX Two-Block Pattern\n1. User or agent submits encrypted data to a contract. It stays encrypted in storage.\n2. When conditions are met, the contract calls `submitCTX()`\n3. Validators batch all decryption requests from block *N*\n4. Block *N+1* executes all `onDecrypt()` callbacks with decrypted data\n:::info\nThe target is N+1 execution, but if block gas is exhausted on a given SKALE chain, decryption can slip to a later block. SKALE's horizontal scaling mitigates this \u2014 dedicated chains avoid the congestion that causes delays. A financial application could run its own SKALE chain to build a unique limit order book with dynamic AMM usage, all powered by CTXs.\n:::\nThis is a two-block operation. The callback executes with an ephemeral sender address \u2014 not the original submitter."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Comparison: Chainlink Automation"
        },
        {
          "role": "assistant",
          "content": "### Comparison: Chainlink Automation\nIf you've worked with Chainlink Automation, the mental model is similar. Both enable condition-triggered smart contract execution. The key difference: CTX adds encryption.\n| Aspect          | Chainlink Automation                | SKALE CTX                               |\n| --------------- | ----------------------------------- | --------------------------------------- |\n| Pattern         | checkUpkeep() \u2192 performUpkeep()     | submitCTX() \u2192 onDecrypt()               |\n| Condition Check | Off-chain DON simulation (OCR3)     | Onchain threshold decryption            |\n| Privacy         | No \u2014 upkeep data is public          | Yes \u2014 data encrypted until decryption   |\n| Dependency      | External oracle network             | Native chain infrastructure             |\n| Latency         | Variable (depends on DON consensus) | N+1 blocks (target)                     |\n| Failure Mode    | performUpkeep can fail/revert       | Atomic execution (subject to block gas) |\n| Cost            | Requires LINK token payments        | Free (zero gas on SKALE)                |"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Breaking EVM Assumptions"
        },
        {
          "role": "assistant",
          "content": "### Breaking EVM Assumptions\nEVM developers assume atomicity. You call a function, state changes, the transaction succeeds or reverts \u2014 all in one block. CTXs break this assumption intentionally.\nWhen `submitCTX()` executes, the decryption does not happen immediately. It queues for the next block's batch decryption. This means:\n* You cannot read decrypted results in the same transaction\n* Logic must be structured as callbacks, not synchronous reads\n* Multiple decryption requests from the same block batch together\nThe batching is the feature. All requests from block *N* decrypt simultaneously in block *N+1*, processed in order of creation. If block gas is exhausted, remaining decryptions roll over to the next block. This eliminates timing advantages \u2014 a sealed-bid auction where all bids decrypt together is fundamentally fairer than sequential reveals."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: The Supplicant Interface"
        },
        {
          "role": "assistant",
          "content": "### The Supplicant Interface\nContracts that receive CTX callbacks implement a standard interface:\n```solidity\ninterface IBiteSupplicant {\n    function onDecrypt(\n        bytes[] calldata decryptedArguments,\n        bytes[] calldata plaintextArguments\n    ) external;\n}\n```\nWhen the committee decrypts, every registered supplicant's `onDecrypt()` fires. This enables complex multi-party workflows where multiple contracts react to the same decryption event.\n*source \u2014 docs*"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Use Cases for AI Agents"
        },
        {
          "role": "assistant",
          "content": "### Use Cases for AI Agents\n**Encrypted Strategy Parameters.** A trading agent stores rebalancing thresholds, price triggers, and position limits encrypted onchain. The contract only decrypts and executes when market conditions match. Competitors see that something triggered \u2014 not what the thresholds were.\n**Sealed Agent-to-Agent Negotiations.** Two agents submit encrypted terms for a task. The contract decrypts both simultaneously when both sides have submitted, executing on the overlap. Neither agent sees the other's terms until reveal \u2014 eliminating first-mover disadvantage.\n**Conditional Autonomous Payments.** Payment triggers fire only after decryption confirms a condition \u2014 delivery of data, completion of compute, verification of a result. This is \"if/then\" financial logic enforced by the chain.\n**Time-Locked Reveals.** Encrypted data that automatically decrypts at a specific block number. Research swarms publish findings simultaneously. Prediction markets seal predictions until events resolve."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: CTXs and Encrypted Transactions"
        },
        {
          "role": "assistant",
          "content": "### CTXs and Encrypted Transactions\n|                     | Encrypted Transactions                   | CTXs                                         |\n| ------------------- | ---------------------------------------- | -------------------------------------------- |\n| What's encrypted    | Transaction data (calldata, destination) | Smart contract storage (state, parameters)   |\n| When it's decrypted | After block finalization                 | When contract triggers CTX                   |\n| Protection model    | Transit encryption                       | Conditional execution on encrypted state     |\n| Developer interface | Transparent (automatic)                  | Callback pattern (`onDecrypt()`)             |\n| Execution model     | Same-block                               | Two-block (request in *N*, execute in *N+1*) |\nTogether they form complete privacy: encrypted in transit, encrypted state executed only when conditions are met."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers."
        },
        {
          "role": "assistant",
          "content": "The barista test: when you buy coffee, the barista doesn't see your bank balance. Confidential tokens bring this privacy to blockchain \u2014 private balances, encrypted amounts, and transfers that reveal nothing to observers.\nThis is not a new primitive. Confidential tokens are an *application* \u2014 a pattern that combines encrypted transactions, conditional transactions, and re-encryption into a single use case. eUSDC is one implementation. The pattern works for any token."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: What Confidential Tokens Demonstrate"
        },
        {
          "role": "assistant",
          "content": "### What Confidential Tokens Demonstrate\nStandard ERC-20 tokens expose everything. Balances. Transfer amounts. Transaction history. Anyone with a block explorer can trace flows, identify whales, and analyze spending patterns.\nConfidential tokens change this:\n| Standard Token           | Confidential Token                    |\n| ------------------------ | ------------------------------------- |\n| Balances public          | Balances encrypted                    |\n| Transfer amounts visible | Amounts encrypted                     |\n| History traceable        | Only sender/recipient see their flows |\n| Contract sees all data   | Contract executes on encrypted state  |\n| No privacy guarantees    | Threshold cryptography secures data   |\ninfo\nThis isn't limited to bridged assets. The same pattern works with a native stablecoin \u2014 any onchain token can have encrypted balances and transfers applied to it.\n:::\nThe SDK usage is straightforward:\n```typescript\nconst method = mpp.charge({\n  chain: 'bite-sandbox',\n  currency: 'eUSDC',\n  extensions: {\n    skale: { encrypted: true, confidentialToken: true },\n    gasless: 'eip3009'\n  }\n})\n```\n`encrypted: true` \u2014 Transaction amount encrypts onchain.\n`confidentialToken: true` \u2014 Uses eUSDC with encrypted balances.\n`gasless: 'eip3009'` \u2014 No gas fees (EIP-3009 permit signature)."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Integration with MPP and x402"
        },
        {
          "role": "assistant",
          "content": "### Integration with MPP and x402\nConfidential tokens combine naturally with MPP (Machine Payments Protocol). I covered this in depth in Confidential MPP on SKALE \u2014 the summary:\nAI agents paying for services via MPP can use confidential tokens to hide both the payment amount and their remaining balance. Only the agent and the service provider see transaction details.\nThis matters for:\n* **Agent spending patterns** \u2014 exact amounts hidden from competitors\n* **Budget constraints** \u2014 total holdings not visible onchain\n:::info\nConfidential tokens encrypt amounts and balances, but the from/to addresses remain public. Transaction counterparts can still be seen onchain.\n:::\nThe same applies to x402 payments. When an agent pays for a tool or API via x402, confidential tokens ensure the payment amount and the agent's balance stay private. The HTTP 402 response triggers a gasless payment \u2014 and with encryption, the chain only sees ciphertext."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: The Pattern, Not The Product"
        },
        {
          "role": "assistant",
          "content": "### The Pattern, Not The Product\neUSDC is one example. The confidential token pattern applies broadly:\n**Private Payroll.** Companies pay employees without revealing salaries to the world. Each employee sees only their own transfers.\n**Agent-to-Agent Payments.** AI agents transact without broadcasting financial positions. Trading bots settle without revealing strategies via payment patterns.\n**Sensitive Transfers.** Donations, legal settlements, and personal payments execute without public scrutiny.\n**Compliance-Ready Privacy.** Re-encryption enables selective disclosure to auditors without revealing data to the public chain. Threshold decryption can trigger for authorized compliance keys.\nAny token can be made confidential using this pattern. These primitives are native to SKALE \u2014 no custom VMs, no circuit languages, no rewrites required."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: What This Enables"
        },
        {
          "role": "assistant",
          "content": "### What This Enables\nConfidential tokens prove that programmable privacy isn't theoretical. The primitives work together to solve real problems:\n1. Encrypted transactions hide amounts in transit (client-side encryption)\n2. Re-encryption delivers private balances to recipients onchain\n3. Conditional transactions enable encrypted state updates (being explored)\nThe result is a token with the same functionality as ERC-20 but privacy properties that match traditional banking. The barista test \u2014 passed."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "::authors\nMEV bots consume over **50% of gas** on leading L2s while paying less than 10% of fees. [\\[1\\]](#sources) But the infrastructure cost is only half the story \u2014 the real damage is to users. Every transaction you submit broadcasts your intent in plaintext to the mempool: amounts, destinations, and strategies visible to every searcher, every validator, every MEV bot. Encrypted transactions change this entirely.\nSKALE embeds threshold encryption into consensus. Validators see ciphertext, not calldata. Amounts, destinations, and intents remain encrypted until a supermajority collaborates to decrypt. This is not a Layer 2 add-on or an external oracle \u2014 it's protocol-level privacy with zero Solidity changes required. No TEEs, no external infrastructure."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: The MEV Problem"
        },
        {
          "role": "assistant",
          "content": "### The MEV Problem\nMEV (Maximal Extractable Value) is profit extracted from transaction ordering. The mempool is a dark forest \u2014 every pending transaction is visible and exploitable. But the risk isn't just abstract market inefficiency. It's your wallet.\n#### How Users Get Hurt\n| Attack Type      | What Happens to You                                                                                                                                                 | Source                     |\n| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------- |\n| Sandwich attacks | You swap 1 ETH for USDC. A bot front-runs your trade, buys the same token, and back-runs \u2014 you get a worse price. The bot pockets the spread. [\\[1\\]](#sources)     | Flashbots, Jun 2025        |\n| Front-running    | Your limit order is visible before execution. Bots place identical orders ahead of yours, filling at better prices and leaving you with slippage. [\\[2\\]](#sources) | Oblivious Labs + Flashbots |\n| Back-running     | After your large trade moves the market, bots immediately trade against the price impact \u2014 extracting value you created. [\\[2\\]](#sources)                          | Oblivious Labs + Flashbots |\n| Intent exposure  | Your trading strategy, position size, and timing are public before execution. Competitors and arbitrageurs react in real time.                                      | \u2014                          |\n| Censorship risk  | Transactions can be filtered based on destination or calldata content before inclusion. Validators see everything.                                                  | \u2014                          |\nThe mechanics are straightforward. A bot sees your swap transaction in the mempool. It front-runs with the same trade, driving up the price. Your transaction executes at the worse rate. The bot back-runs to capture the spread. This is a sandwich attack \u2014 profitable, legal, and entirely extractive. You pay the cost every time.\n#### The Problem Is Getting Worse\nPrivate mempools were supposed to solve this. Instead, they created a new arms race. Flashbots' 2025 research shows that MEV bots now consume **over 50% of gas** on top rollups [\\[1\\]](#sources) \u2014 they probe the chain with hundreds of failed transactions for every successful extraction, pushing fees up for everyone. A single arbitrage on Base requires \\~350 failed transactions (\\~132M gas). The same outcome that costs 200K gas on Ethereum costs 130M gas on Base \u2014 a **650x efficiency gap**. The infrastructure cost of MEV is passed directly to users through higher fees and worse execution.\nFlashbots' \"MEV and the Limits of Scaling\" [\\[1\\]](#sources) concluded that MEV has become \"the dominant limit to scaling blockchains\" \u2014 and the primary victim is the end user."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: What Encrypted Transactions Solve"
        },
        {
          "role": "assistant",
          "content": "### What Encrypted Transactions Solve\nEncrypted transactions make the mempool opaque. Validators reach consensus on encrypted payloads. No one sees amounts, destinations, or function calls until after finalization.\nThreshold encryption uses:\n* **AES encryption** for transaction data\n* **BLS threshold encryption** for committee-based decryption\n* **Supermajority consensus** \u2014 >2/3 of validators required\n* **Automatic decryption** post-finalization\nThe result: full mempool privacy during consensus. No front-running. No sandwich attacks. No back-running."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: How It Works"
        },
        {
          "role": "assistant",
          "content": "### How It Works\n  !Transaction Flow Comparison\nThe top shows the vulnerability: transactions broadcast in plaintext to the mempool, visible to MEV bots that can sandwich attack. The bottom shows encrypted transactions: amounts and destinations remain hidden until finalization.\nThe committee public key encrypts. The committee private key \u2014 split across validators via threshold cryptography \u2014 decrypts. No single validator can decrypt alone. No external infrastructure required.\nFrom a developer perspective, the change is minimal:\n```typescript\nconst encryptedTx = await bite.encryptTransaction({\n  to: contractAddress,\n  data: calldata,\n  value: amount\n})\nawait wallet.sendTransaction(encryptedTx)\n```\nThat's it. No contract rewrites. No circuit languages. No proving systems.\n*source \u2014 docs*"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Use Cases"
        },
        {
          "role": "assistant",
          "content": "### Use Cases\n**Private DeFi.** Traders execute without broadcasting their positions. Strategies remain hidden until execution. No MEV extraction possible.\n**Confidential Intents.** Users express desired outcomes \u2014 \"swap ETH for USDC at market rate\" \u2014 without revealing amounts or slippage tolerances. Solvers compete without seeing each other's bids.\n**MEV-Resistant Settlement.** DCA (Dollar-Cost Averaging), TWAP (Time-Weighted Average Price), and other automated strategies execute without broadcasting timing or quantities.\n**Censorship Resistance.** Encrypted transactions cannot be selectively filtered based on content. Validators see only ciphertext until consensus is reached.\n***\n1. Flashbots, \"MEV and the Limits of Scaling,\" June 16, 2025. https://writings.flashbots.net/mev-and-the-limits-of-scaling\n2. Oblivious Labs + Flashbots, \"Scalable Oblivious Accesses to Blockchain Data,\" June 2, 2025. https://writings.flashbots.net/scalable-oblivious-accesses-to-blockchain-data\n3. Flashbots, \"Decentralized Building: Wat Do?,\" February 14, 2026. https://writings.flashbots.net/decentralized-building-wat-do"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples."
        },
        {
          "role": "assistant",
          "content": "You encrypted data for one party. Now you need to share it with another \u2014 without revealing it to the world. Re-encryption makes this possible onchain.\nSKALE's re-encryption primitive allows encrypted data to be forwarded across blocks and selectivley shared in two ways:\n1. With a viewer key (i.e so each player's poker hand is encrypted for that specific player)\n2. With the public bls key (i.e so the validators can decrypt and re-encrypt information across blocks)\nThe former is great for selective information that needs to be shared but not acted within the smart contracts on. The latter is perfect for when information needs to be stored privatley onchain and used within Solidity without leaking the information to the world."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: The Problem"
        },
        {
          "role": "assistant",
          "content": "### The Problem\nOnce data is encrypted to a specific key, standard encryption traps it. Either the holder decrypts and re-encrypts manually (exposing plaintext) or the data stays locked to the original recipient.\nOnchain, this is worse. Smart contracts \\[normally] can't hold secrets \u2014 any decrypted state is visible to all validators."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: What Re-Encryption Enables"
        },
        {
          "role": "assistant",
          "content": "### What Re-Encryption Enables\nRe-encryption uses threshold cryptography to transform ciphertext encrypted to one key into ciphertext decryptable by another \u2014 the committee decrypts via CTX, then re-encrypts to the new recipient."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Use Cases"
        },
        {
          "role": "assistant",
          "content": "### Use Cases\n**Onchain Information Sharing.** Medical records, financial data, or proprietary research stored encrypted onchain can be selectively shared with new parties. The original holder authorizes \u2014 the chain executes the re-encryption without seeing content.\n**Private Data Delegation.** An agent holding encrypted data can delegate access to another agent without transferring the decryption key. The delegator specifies the new recipient; validators handle the cryptographic transformation.\n**Confidential Tokens.** Token balances encrypted to holder keys. Transfers re-encrypt to the recipient's viewer key. The contract never sees plaintext balances \u2014 only the sender and recipient can decrypt their own data.\n**Encrypted Messaging Patterns.** Messages encrypted onchain that can be forwarded to new participants. Group membership changes without decrypting message history."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: How It Works"
        },
        {
          "role": "assistant",
          "content": "### How It Works\nThe protocol provides two encryption modes:\n* **Threshold Encryption (TE)** \u2014 `BITE.encryptTE()` encrypts data to the validator committee. Only a supermajority of validators can decrypt, triggered via a CTX callback. Think of it as a sealed envelope that only the network can open.\n* **Viewer Key Encryption (ECIES)** \u2014 `BITE.encryptECIES()` encrypts data to a specific public key (secp256k1). Only the holder of the corresponding private key can decrypt \u2014 client-side, no committee required. Think of it as a sealed envelope addressed to one person.\nRe-encryption bridges these. Data encrypted via TE can be decrypted through a CTX callback, then re-encrypted to any viewer key within the same callback.\n  !Re-encryption Flow\nThe committee holds threshold shares of the private key. No single validator can decrypt alone. A supermajority must collaborate to decrypt via CTX, and the contract's `onDecrypt` callback handles re-encryption to the recipient's viewer key.\n```solidity\n// Store threshold-encrypted data\nbytes memory encryptedData = BITE.encryptTE(BITE.ENCRYPT_TE_ADDRESS, plaintext);\n// Later: submit CTX to decrypt and re-encrypt in callback\nBITE.submitCTX(BITE.SUBMIT_CTX_ADDRESS, gasLimit, encryptedArgs, plaintextArgs);\n// The onDecrypt callback then calls BITE.encryptECIES() with the viewer key\n```\n*source \u2014 docs*"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Real Example: Confidential Poker"
        },
        {
          "role": "assistant",
          "content": "### Real Example: Confidential Poker\nThe live poker demo demonstrates re-encryption in practice \u2014 read the full walkthrough here. Here's how it works:\nWhen cards are dealt, each hole card is:\n1. Threshold encrypted (`encryptTE`) for the showdown reveal\n2. ECIES encrypted (`encryptECIES`) to the player's viewer key for client-side viewing\nDuring the hand, only the player can see their hole cards \u2014 decrypted via their private key. At showdown, a CTX decrypts the threshold-encrypted version to evaluate the winner. No single entity ever sees all cards unencrypted until the protocol triggers reveal.\nThis pattern applies beyond poker:\n* Private document sharing with viewer-key access\n* Confidential escrow where terms encrypt to mediator and participants\n* Selective disclosure for compliance (re-encrypt to auditor keys)"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Re-Encryption + CTXs"
        },
        {
          "role": "assistant",
          "content": "### Re-Encryption + CTXs\nRe-encryption becomes more powerful combined with Conditional Transactions. A contract can:\n1. Store threshold-encrypted data\n2. Wait for conditions (time, payment, approval)\n3. Trigger a CTX that re-encrypts to a new recipient\n4. The new recipient receives without ever touching plaintext onchain\nThis is \"encrypted info block over block\" \u2014 data flows through the chain, transforming in encrypted form, only decrypting at final destinations."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Building with Re-Encryption"
        },
        {
          "role": "assistant",
          "content": "### Building with Re-Encryption\nIf you're building applications that need private data sharing \u2014 onchain info sharing, data delegation, confidential tokens \u2014 re-encryption is live on SKALE chains. No external infrastructure. No TEEs. Standard Solidity patterns.\nReach out if you want to better understand how re-encryption and programmable privacy could help your business.\n***\n1. SKALE BITE Documentation, https://docs.skale.space\n2. SKALE BITE Solidity Library, https://github.com/skalenetwork/bite-solidity\n3. Confidential Poker Implementation, https://github.com/TheGreatAxios/confidential-poker"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples."
        },
        {
          "role": "assistant",
          "content": "Poker failed onchain because cards were visible. Every attempt \u2014 state channels, commit-reveal schemes, TEEs \u2014 compromised on speed, trust, or decentralization. Threshold encryption fixes this.\nThe live demo is running now: confidential-poker.vercel.app. AI agents play Texas Hold'em with encrypted hole cards, threshold-encrypted community cards, and onchain settlement. This is what programmable privacy enables \u2014 fair gaming with no trusted intermediaries."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Why Poker Needs Privacy"
        },
        {
          "role": "assistant",
          "content": "### Why Poker Needs Privacy\nTexas Hold'em has two information layers:\n1. **Hole cards** \u2014 private to each player until showdown\n2. **Community cards** \u2014 public after each dealing phase\n3. **Actions** \u2014 public (bets, folds, raises)\nOn a standard blockchain, storing hole cards onchain means publishing them. Commit-reveal schemes add friction \u2014 players must come back online to reveal. State channels require liveness guarantees and dispute periods.\nDual encryption solves this:\n* **Threshold encryption (TE)** \u2014 Cards encrypt to the committee for later decryption\n* **ECIES encryption** \u2014 Cards encrypt to each player's viewer key for immediate viewing\nHole cards are dealt once, encrypted both ways. Players see their cards immediately via ECIES decryption. The contract holds TE-encrypted versions for showdown. Community cards deal via CTX callbacks \u2014 encrypted until the protocol reveals them."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Technical Implementation"
        },
        {
          "role": "assistant",
          "content": "### Technical Implementation\n#### Smart Contracts\nThree contracts run on SKALE Base Sepolia:\n* **PokerGame.sol** \u2014 Game state, betting rounds, hand orchestration\n* **HandEvaluator.sol** \u2014 Onchain hand ranking and winner determination\nThe core dealing function:\n```solidity\nfunction dealHoleCards(address player, bytes32 cardHash) external {\n    // Threshold encrypt for showdown reveal\n    bytes memory teEncrypted = BITE.encryptTE(cardHash, committeePublicKey);\n    // ECIES encrypt to player's viewer key\n    bytes memory eciesEncrypted = BITE.encryptECIES(cardHash, playerViewerKeys[player]);\n    // Store both versions\n    playerCards[player] = PlayerCards(teEncrypted, eciesEncrypted);\n}\n```\n#### Community Card Dealing\nThe flop, turn, and river deal via CTX callbacks:\n```solidity\nfunction dealFlop() external {\n    // Three cards, encrypted to committee\n    bytes[3] memory encryptedCards = encryptCards(3);\n    // Submit CTX for batch decryption\n    BITE.submitCTX(\n        BITE.SUBMIT_CTX_ADDRESS,\n        gasLimit,\n        abi.encode(encryptedCards),\n        abi.encode(uint8(3)) // card count\n    );\n}\nfunction onDecrypt(bytes[] calldata decryptedArguments, bytes[] calldata plaintextArguments) external {\n    // Executed in next block with decrypted cards\n    uint8[52] memory liveDeck = abi.decode(decryptedArguments[0], (uint8[52]));\n    communityCards[0] = liveDeck[deckPosition];\n    communityCards[1] = liveDeck[deckPosition + 1];\n    communityCards[2] = liveDeck[deckPosition + 2];\n    emit FlopDealt(communityCards[0], communityCards[1], communityCards[2]);\n}\n```\nSame pattern for turn (1 card) and river (1 card). Each phase queues in one block, decrypts and executes in the next.\n*source*"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Architecture Overview"
        },
        {
          "role": "assistant",
          "content": "### Architecture Overview\n  !Poker Architecture\nThe server handles game orchestration because card dealing requires sequential operations that don't fit single transactions. The contracts hold truth \u2014 game state, encrypted cards, betting balances. The server translates between player actions and onchain state.\nSix AI agent personalities run in the server layer \u2014 each with distinct aggression levels, bluff frequencies, and playing styles. They evaluate hand strength, pot odds, and opponent patterns through a unified decision engine."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Dual Encryption in Practice"
        },
        {
          "role": "assistant",
          "content": "### Dual Encryption in Practice\nWhen hole cards deal:\n1. Server generates random cards (52-card deck, shuffled via SKALE RNG)\n2. Cards encrypt via `BITE.encryptTE()` \u2014 committee decrypts at showdown\n3. Cards encrypt via `BITE.encryptECIES()` \u2014 player decrypts client-side\n4. Both versions stored onchain in `playerCards` mapping\nPlayers see their cards immediately via client-side ECIES decryption. The contract can't see hole cards \u2014 only the TE-encrypted blobs. At showdown, a CTX triggers committee decryption, `onDecrypt()` evaluates hands, and winners receive payouts.\nThis pattern \u2014 dual encryption with different reveal conditions \u2014 applies beyond gaming:\n* **Sealed-bid auctions** \u2014 Bidders see their own bids via ECIES; contract reveals all via TE at close\n* **Private voting** \u2014 Voters confirm their vote via ECIES; results reveal via TE after deadline\n* **Time-locked data** \u2014 Immediate access via ECIES; public reveal via TE at trigger time"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: What This Proves"
        },
        {
          "role": "assistant",
          "content": "### What This Proves\nConfidential poker demonstrates that programmable privacy works at scale:\n* **Real-time gameplay** \u2014 No commit-reveal delays, no dispute periods\n* **Fair dealing** \u2014 Cards encrypted onchain, decrypted by protocol rules\n* **AI agents** \u2014 Six distinct personalities making encrypted decisions\n* **Live demo** \u2014 Playable now, not theoretical\nThe cryptography is production-ready. The UX matches Web2 expectations. The agents operate autonomously with private state.\nThis is the foundation for fair onchain gaming \u2014 not just poker, but any game with hidden information. Bridge, Hearts, Mahjong, strategy games with fog of war. All become possible when encrypted state is a native primitive."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Repository and Demo"
        },
        {
          "role": "assistant",
          "content": "### Repository and Demo\n* **Live Demo:** confidential-poker.vercel.app\n* **Stack:** Vite, React 19, Hono, Foundry, Programmable Privacy\n* **Status:** Complete and deployed\n* **Want to play?** DM me on X @thegreataxios for tokens to try it out\nThe repository is open source. If you're building confidential games, agent systems, or encrypted data flows, the patterns here are ready to adapt.\nI'm actively building on SKALE daily. DM me if you want to walk through the implementation, integrate threshold encryption into your game, or explore confidential agent patterns.\n***\n1. SKALE BITE Documentation, https://docs.skale.space\n2. SKALE BITE Solidity Library, https://github.com/skalenetwork/bite-solidity\n3. Confidential Poker Source Code, https://github.com/TheGreatAxios/confidential-poker\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "This article explores the revolutionary BITE Protocol that implements Proof of Encryption using threshold cryptography and multi-party signatures to enable fully encrypted blockchain transactions resistant to MEV attacks. Unlike traditional trusted execution environments, BITE embeds encryption directly into consensus through provable mathematics, requiring zero Solidity changes while offering cloud API accessibility for encrypted transactions across any programming language, with FAIR L1 blockchain pioneering the implementation before broader SKALE Chain adoption.\n**BITE** is an innovative protocol from the SKALE Network ecosystem, launching first on the new **FAIR Layer 1 blockchain**. Designed for seamless integration and massive potential, BITE enables a wide range of critical functions\u2014ushering in a new era of encrypted, private, and MEV-resistant blockchain usage.\nThe following post explores the key benefits of BITE, FAIR, and the upcoming SKALE Network upgrade, including a **unique way to attain Proof of Encryption (PoE) with zero changes required from developers**."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: The Benefits of BITE"
        },
        {
          "role": "assistant",
          "content": "### The Benefits of BITE\nWhile some of these benefits can arrive sooner depending on SDK implementation and adoption, I\u2019ve organized them into **short**, **mid**, and **long-term** buckets.\n#### \ud83d\udfe2 Short Term\n* Fully encrypted transactions with 100% protection against MEV, including back-running\n* Onchain traditional finance tools: private and FAIR TWAPs, DCA, and market orders\n* Censorship resistance\n* Simple integration with **zero changes to Solidity**\n#### \ud83d\udfe1 Mid Term\n* AI-powered onchain trading via enhanced encrypted financial tools\n* End-to-end encryption with re-encryption inside a TEE (Trusted Execution Environment), enabling data forwarding to specific parties for private decryption\n#### \ud83d\udd35 Long Term\n* Fully encrypted private state\n* Onchain healthcare and banking use cases\n* Fully encrypted **parallel execution** within the EVM\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: How Proof of Encryption Works"
        },
        {
          "role": "assistant",
          "content": "### How Proof of Encryption Works\n**Proof of Encryption (PoE)** embeds encryption into the consensus layer of a blockchain. Unlike Layer 2 solutions (e.g. Unichain) that use TEEs in isolation, PoE **does not depend on decentralization alone**\u2014it relies on **provable mathematics**.\n> The SKALE Network core team has over seven years of experience building the world\u2019s fastest leaderless BFT consensus. They\u2019ve combined real-world application with rigorous mathematical proofs to pioneer PoE.\n#### \ud83e\udde0 How It Works\nPoE uses:\n* **Threshold schemes** +\n* **BLS threshold encryption** +\n* **Multi-party threshold signatures** +\n* **Economic PoS security**\nThis combo allows encrypted transaction propagation, leaderless/asynchronous consensus, and decryption via supermajority\u2014all secured cryptographically and economically.\nThe result? **Private, MEV-resistant, decentralized consensus**\u2014unlocking trillions in new financial use cases.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: How to use BITE"
        },
        {
          "role": "assistant",
          "content": "### How to use BITE\n**BITE Protocol** is the implementation of PoE when used with a compatible blockchain like FAIR or (soon) SKALE Chains.\nThe best part? **Zero changes to your Solidity contracts**.\n#### Example Using BITE TypeScript/JavaScript Library\n!Image\n```bash\nnpm add @skalenetwork/bite\n```\nThe library makes it easy to encrypt both transaction data and the `to` address in just a few lines of code.\n***\n#### What's with the Cloud?\nOver the last several years of working in blockchain, I\u2019ve realized one thing: **an innovative product is only useful if it\u2019s easy to implement**. That\u2019s why I collaborated with @0xRetroDev to build a simpler, cloud-based design for broader adoption.\n#### Background\nIf you\u2019ve heard of **Flashbots**, **CoW Swap**, or **Jito**, you know they\u2019re tied to **MEV** (Maximal Extractable Value). If not, here\u2019s a simplified breakdown:\n* **MEV** is profit gained by reordering or inserting transactions.\n* **Bad MEV** = front-running, sandwich attacks, back-running.\n* **Good MEV** = arbitrage, liquidations that help price stability or protocol solvency.\n* **Some firms (e.g. Jito)** make validators more profitable via MEV.\n* **Others (e.g. CoW Swap)** attempt to *protect users* from MEV.\n> **Bottom line:** MEV is mostly harmful and extracts value away from users.\n#### Simplifying Adoption\nWidespread usage builds a **network effect**. Just as Jito dominates Solana validators and MEV-blocker RPCs like CoW Swap are spreading, we aim for BITE to be universally accessible\u2014across stacks, devices, and languages.\n#### Phase I: BITE API\nA PoC implementation is already live thanks to @0xRetroDev:\\\n\ud83d\udd17 BITE API GitHub Repo\nThis API allows any transaction to be encrypted by calling the endpoint. It\u2019s ideal for:\n* Environments without native BITE SDKs\n* Languages outside JavaScript/TypeScript\n* Setting up early MPC experiments or agentic flows\n> \u26a0\ufe0f **Note:** Because `eth_estimateGas` can't work properly with encrypted transactions, this can unintentionally leak user intent if used via 3rd-party RPCs.\nA production-ready version will soon be hosted via Eidolon.gg for the FAIR + SKALE Communities.\n***\n#### Phase II: Private BITE API\nTo fully solve the **privacy problem**, we propose a unique infrastructure setup modeled on how FAIR and SKALE operate.\n##### Infrastructure\n1. Run a TEE (Trusted Execution Environment)\n2. Generate a private key *inside* the TEE\n3. Expose the **public** key via API\n##### SDK Flow\n4. Client requests public key\n5. Client encrypts transaction payload using public key\n6. TEE decrypts using internal private key\n7. TEE re-encrypts using FAIR/SKALE BLS committee key\n8. Returns encrypted payload to client\n9. Client signs + broadcasts\nThis allows **any client**\u2014C++, Kotlin, IoT, etc.\u2014to securely use BITE without needing full Web3 tooling or native SDK support.\nYes, there are risks and trade-offs here. But I believe this is a great **early-stage design** for broader PoE adoption.\n***"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "This technical guide addresses the critical scaling challenges faced by authoritative servers in blockchain applications due to the EVM's sequential nonce requirement. By implementing a Signing Pool architecture using HD wallet-derived child signers, developers can overcome nonce collision issues and scale from handling just a few concurrent requests to hundreds per second, complete with automatic gas balance management and dynamic signer selection for high-throughput applications on zero-gas-fee networks like SKALE.\nThe Ethereum Virtual Machine (EVM) is a distribute decentralized environment that executes code across all nodes in an EVM Network \\like [Ethereum and SKALE]. In order to ensure that transactions cannot be replayed, the EVM utilizes a nonce value per account.\nThe account\u200a\u2014\u200aoften known as the wallet or the private key\u200a\u2014\u200amust send transactions with sequential nonces in order to have successful execution. However, this is a direct limitation when exploring applications necessary architecture. Knowing that blockchain is a broader piece of the architectural stack for many; it\u2019s no surprise that many developers lean on various types of centralized services operated by their team to \u201cmanage\u201d their application. These centralized services are best referred to as\u00a0**Authoritative Servers.**\n#### Authoritative Servers\nServers that help manage and maintain the state of an application are a necessary evil. There are exceptions to the rule where some applications are able to create a suite of smart contracts that don\u2019t rely on an external manager, however, in most cases the technical overhead is too large or difficult.\nRunning a server or many servers to manage authority within a game brings its own set of complications. Traditional CRUD APIs using Python + Flask, or Node.js + Express typically fall prey to a number of issues including: race conditions, lack of security, rate limits, etc. Blockchain CRUD APIs through a combination of 3rd party resources (e.g the blockchain) and race conditions can have issues related to scaling the accounts and their nonces.\n* **Race Conditions:**\u00a0A race condition is a software error that can occur when multiple processes or threads attempt to access the same data but the context is uncoordinated.\n* **Lack of Security:**\u00a0APIs themselves should require some form of authentication to utilize. Often times blockchain engineers don\u2019t create authentication and authorization layers for their apps based on the user wallets which can open up the door for spam against various routes and even drain server gas tokens and funds.\n* **Rate Limits:**\u00a0When linking to 3rd party services whether a cloud database or a blockchain; rate limits during surges in use of a platform can really cause headaches.\n* **Unscalable Nonces:**\u00a0The blockchain specific issue occurs on EVM chains that have sequential nonces. During contract execution, the next nonce is usually set by the pending value from the chain itself. However, a single account trying to manage hundreds or thousands of requests at the same time can be overloaded and cause nonces to break.\n#### Pitfalls of a Single\u00a0Account\nThe use of a single account to manage a server is very common, however, not designed for scalability. Imagine the following Node.js + Express controller:\n```ts\n// controller.ts  \ntype RequestBody = {  \n  gameId: string;  \n  userWalletAddress: `0x${string}`;  \n}  \nexport default async function(req: Request, res: Response) {  \n  // Access to gameId str and userWalletAddress ethereum address  \n  const { gameId, userWalletAddress } : RequestBody = req.body;  \n  try {  \n    // Provider connects to SKALE Calypso Mainnet  \n    const provider = new JsonRpcProvider(\"https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague\");  \n    // Wallet is for the server (one key) and uses the Calypso provider  \n    const wallet = new Wallet(\"...privateKey\", provider);  \n    // Contract connects to a contract on-chain that stores on-chain game analytics  \n    // This contract uses the wallet and provider above  \n    const contract = new Contract(\"0x...\", [...abi], wallet);  \n    await contract.logPlay(gameId, userWalletAddress);  \n    return res.send(200).status(\"Event Logged\");  \n  } catch (err) {  \n    // Avoid sending private information to the client  \n    return res.status(500).send(\"Internal Server Error\");  \n  }  \n}  \n// router.ts  \nconst router = Router();  \nrouter.post(\"/games/play\", controller);  \nexport default router;\n```\nIn the above code, a single wallet is being used to execute transactions for every request that hits the\u00a0`POST /games/play` endpoint. If multiple requests start to come in at the same time, the blockchain request will begin to error out since the\u00a0*Pending Nonce*\u00a0would the the same for multiple requests at which point only the first would succeed.\nOne solution that has worked well for many of the projects I\u2019ve worked with is to utilize a queue system. This can certainly work to ensure that nonces stay sequential, however, this does slow down responses back to the client during heavy load.\n#### Upsides of a\u00a0Pool\nThe concept of a\u00a0**Pool of Signers**\u00a0came about when I was doing solutions architecture for a Web2 to Web3 game transition. The game itself at the time was fully operational on Android and had a backend already built as part of it\u2019s Web2 v2 build. Moving into the v3 build, the goal was to help bring greater visibility on-chain of the actual game and then utilize this visibility to help manage and validate incentives.\nDuring the initial design of the v3, it became clear that one of the biggest limitations was the existing and actively growing user-base. Since critical actions for the user were gated by the in-game token, it made sense to push as many of those actions as possible to the client for greater scalability and utilization of the blockchain. However, the server acted as a gateway to Web3 for guest accounts as well as offering critical authority based on more traditional API calls from client to server.\nIt became clear that a single signer on a single server just would not be efficient. From there, two different designs came about. The first was to utilize a pool of multiple signers to handle higher load. This allowed each account in the pool to send one transaction at a time before the next signer was selected. With some strategic decisions made to abstract the Signing Pool over to a separate resource that all the controllers (or underlying services) could call into; it allowed scalability to go from a few requests per second with no issue to hundreds of requests per second with no issue.\n```ts\n// engineManager.ts  \ntype InternalSigner = {  \n    wallet: Wallet;  \n    nonce: number;  \n    active: boolean;  \n    checks: {  \n        gas: boolean;  \n    }  \n}  \nclass SigningManager {  \n    #currentSignerIndex = 0;  \n    #baseWallet: HDNodeWallet;  \n    #rpcUrl: string;  \n    #signers: {[key: number]: InternalSigner} = {};  \n    protected baseProvider: JsonRpcProvider;  \n    constructor(        seed: string,  \n        signerCount: number = 1,  \n        rpcUrl: string    ) {  \n        this.signerCount = signerCount;  \n        this.#rpcUrl = rpcUrl;  \n        this.baseProvider = new JsonRpcProvider(rpcUrl);  \n        this.#baseWallet = Wallet.fromPhrase(seed, this.baseProvider);  \n        this._initializeWallets(signerCount);  \n    }  \n    private async _initializeWallets(signerCount: number) {  \n        let addresses = [];  \n        for (let i = 0; i < signerCount; i++) {  \n            const _wallet = new Wallet(this.#baseWallet.deriveChild(i).privateKey, new JsonRpcProvider(this.#rpcUrl));  \n            this.#signers[i] = {  \n                wallet: _wallet,  \n                nonce: await _wallet.getNonce(),  \n                active: true  \n            };  \n            addresses.push(_wallet.address);  \n        };  \n        if (process.env.NODE_ENV === \"development\") console.log(`Wallets for ${this.use}`, addresses.join(\",\\n\"));  \n    }  \n    public async sendTransaction(request: TransactionRequest) : Promise<TransactionReceipt> {  \n        const signerIndex = this.selectSignerIndex();  \n        const signer = this.#signers[signerIndex];  \n        const balance = await this.baseProvider.getBalance(signer.wallet.address);  \n        if (balance === BigInt(0) && balance > BigInt(request.value ?? 0)) {  \n            this.#signers[signerIndex - 1] = {  \n                ...signer,  \n                active: false,  \n                checks: {  \n                    gas: true,  \n                }  \n            };  \n            return await this.sendTransaction(request);  \n        }  \n        const tx = await signer.wallet.sendTransaction({  \n            gasPrice: 100_000, // set for SKALE to maintain lowest gas consumption  \n            ...request  \n        });  \n        return await tx.wait();  \n    }  \n    private get signerCount() {  \n      return Object.keys(this.#signers).length;  \n    }  \n    private selectSignerIndex() {  \n        const signerIndex = this.#currentSignerIndex;  \n        if (signerIndex + 1 === this.signerCount) {  \n            this.#currentSignerIndex = 0;  \n        } else {  \n            this.#currentSignerIndex++;  \n        }  \n        return signerIndex;  \n    }  \n}  \nexport default new SigningManager();\n```\n````ts\n// controller.ts  \ntype RequestBody = {  \n  gameId: string;  \n  userWalletAddress: `0x${string}`;  \n}  \nexport default async function(req: Request, res: Response) {  \n  // Access to gameId str and userWalletAddress ethereum address  \n  const { gameId, userWalletAddress } : RequestBody = req.body;  \n  try {  \n    await SigningManager.sendTransaction({  \n      to: \"0x...contractAddress\",  \n      data: contract.interface.encodeFunctionData(  \n        \"logPlay\",  \n        [gameId, userWalletAddress]  \n      )  \n    });  \n    return res.send(200).status(\"Event Logged\");  \n  } catch (err) {  \n    // Avoid sending private information to the client  \n    return res.status(500).send(\"Internal Server Error\");  \n  }  \n}```\n```ts  \n// router.ts  \nconst router = Router();  \nrouter.post(\"/games/play\", controller);  \nexport default router;\n````\nThe addition of the signing manager not only makes the controls cleaner, but it allows for a range of 1 to 2\u00b2\u2075\u2076-1 signers in the single engine manager. Of course subject to local resources on the machine. Every signer in the batch manager must have the necessary amount of gas, but especially when designing solutions like this on SKALE; you have the ability to have contract calls top up the signers every time so they never running out.\nThe solutions listed above aren\u2019t for all developers. You can of course modify this in a number of ways including adding different managers per route for maxmium scalability. You should always use a different seed per server to avoid conflicting nonces across multiple machines as well.\nAdditionally, it is important to note that this solution does\u00a0**NOT**\u00a0utilize Account Abstraction/ERC-4337 in any way. That functionality can be useful to handle client operations, however, this is designed for secured authority. The above code examples are all great examples of how to design a highly-scalable authority layer for your next Web3 project.\n***\nFor builders interested in taking advantage of this, make sure to head over to\u00a0https://docs.skale.space\u00a0and start building now."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples."
        },
        {
          "role": "assistant",
          "content": "This governance update examines SKALE Network's remarkable achievement of surpassing 1 billion cumulative transactions while maintaining zero gas fees and instant finality. The analysis covers the SKALE DAO's hybrid governance model combining onchain economic voting with offchain technical consensus, and explores how the upcoming FAIR L1 blockchain addresses critical ecosystem challenges by enabling permissionless DeFi deployment and reducing operational costs through a synergistic gas-fee architecture that captures value within the SKALE ecosystem.\nI've been building in the SKALE Ecosystem for somewhere in the range of 4-5 years now.\nIn that time, I've worked with a lot of projects in the ecosystem and Web3 as a whole.\nI have prepared a quick update from my perspective regarding SKALE, active governance initiatives, and the new L1 coming to support the SKALE Ecosystem from the SKALE team called FAIR.\nYou can read the forum post here or read directly here on my blog.\nSKALE is one of the most innovative blockchain networks in the world. FAIR is designed to help grow the SKALE ecosystem. Adding a real Layer 1 network to the SKALE ecosystem\u2014if executed correctly\u2014will create a synergistic effect. It also allows the SKALE project to continue its history of innovation while bringing a critical component the network has struggled to attract: decentralized value."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Background"
        },
        {
          "role": "assistant",
          "content": "### Background\nTo the decentralized SKALE Network Community of SKL token holders, SKL delegators, validators, builders, core developers, and users:\nSKALE is an open-source, community-driven project that has operated with a clear North Star for over seven (7) years: bringing the power of Ethereum to billions.\nOver the years, SKALE has achieved a variety of incredible innovations, including but not limited to:\n* The launch of the world\u2019s first natively EVM multi-chain scaling solution in 2020, **the SKALE Network**\n* The launch of the world\u2019s first network of EVM blockchains capable of interchain communication through the **SKALE V2** upgrade\n* The launch of **SKALE V3** in 2024, which doubled throughput (TPS) and reduced block mining time in half, making the already performant network even faster\nAll of these key industry-changing events and upgrades were done across a decentralized network of operators running hundreds of nodes. Additionally, SKALE brought the world a variety of innovations that the rest of the blockchain space has struggled to replicate without centralization or high fees such as:\n* Trusted Execution Environment (TEE)-based security\n* Onchain Machine Learning\n* Provable Random Number Generation\n* Decentralized file storage and Content Delivery Network (CDN)\n* Decentralized TEE-protected oracle\n* Multi-transaction Mode\n* Decentralized and fully autonomous bridging\nArguably the most important and well-known innovation that SKALE has brought to the world\u2014and continues to dominate with to this day\u2014is the zero gas fee model, backed by high collateral, high performance, and a sophisticated economic model."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Update on SKALE"
        },
        {
          "role": "assistant",
          "content": "### Update on SKALE\nThe past year has been an explosive period of growth and excitement for the SKALE Network.\nOn the ecosystem side, SKALE hit **1B+ cumulative transactions and 100M+ transactions in a single month** (source). Gaming adoption continues to flourish, with launches of amazing games like Gunnies and Data2073 being highly successful, as well as established SKALE Network games like World of Dypians, Pixudi, and BitHotel continuing to grow and push more and more on SKALE. SKALE also rolled out a $2M Indie Game Accelerator, became the first and only blockchain in Unity\u2019s Publisher Program, and more recently onboarded projects in other key areas like AxonDAO\u2014a unique DeSci project focused on enhancing the value and privacy of health data\u2014and many others like XO (AI) and ReneVerse (Advertising).\nOn the technical front, SKALE announced **BITE Protocol**. BITE, which stands for Blockchain Integrated Threshold Encryption, is the basis for the future of a private and secure EVM that sacrifices nothing in terms of performance or decentralization. This shift will give developers access to trustless privacy by default with all the tools they know and use.\nSKALE has also made major technical strides with the announcement of FAIR, the world\u2019s first MEV-resistant Layer 1 blockchain that brings encrypted, asynchronous execution to the EVM. It will pioneer the use of BITE Protocol and set the stage for SKALE Chains to adopt and upgrade to the FAIR SDK.\nSupporting tools and infrastructure like the SKALE Portal\u2014which recently upgraded to v4.1\u2014and the SKALE Explorer also saw major UX and infrastructure upgrades alongside a major overhaul to the SKALE Network Documentation from a combination of network constituents, including core developers and 3rd-party contributors.\nWith FAIR unlocking DeFi and liquidity for SKALE while also offering a key enhancement for network operations, SKALE is well positioned to be the most dominant network of blockchains in the world."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Refresher on the SKALE DAO and SKALE Network Onchain Governance"
        },
        {
          "role": "assistant",
          "content": "### Refresher on the SKALE DAO and SKALE Network Onchain Governance\nThe SKALE DAO design embodies similar designs to the most successful Layer 1 ecosystems in the world like Ethereum and Solana, which both utilize an offchain forum and development process backed by various entities, core teams, foundations, as well as other 3rd-party contributors to develop the network.\nOne difference these projects have from SKALE is that Ethereum and Solana do not have any onchain governance. All network decisions are made ultimately by those who can execute pull requests in GitHub. There is no voting, just conversation and ultimately a decision made by project leaders and contributors.\nThe SKALE DAO further decentralizes the above process by allowing the SKL delegators to directly collaborate on the economic direction of the network by voting on network economic parameters such as inflation, slashing, chain pricing, etc. It empowers SKL token holders\u2014specifically delegators\u2014to shape the network\u2019s economic direction by proposing initiatives and voting directly on key economic parameters.\nIt is very important to note that many project decisions that lie outside of the direct economic factors as mentioned above are intentionally excluded from onchain voting and are instead determined through conversations and discussions amongst a large group of stakeholders, concluding with an offchain consensus. Said otherwise, SKALE makes decisions outside of direct economic factors in the same way Ethereum and Solana make decisions. Decisions involving roadmap, product development, engineering project planning and prioritization, grants, marketing strategy, and business development continue to fall under the purview of key network contributors such as validators, dApp developers, and core team contributing entities like SKALE Labs.\nYou can read more about the DAO governance here:\n* https://snapshot.box/#/s\\:skale.eth/proposal/0xebbc76cf6bd1afd7e1271f4339c7c04703dbe8dda78b1a731ffaf126772c0051\n* https://forum.skale.network/t/a-proposal-for-skale-networks-on-chain-governance-system/447\nA good example of this in action is comparing chain pricing decisions and recent product roadmap decisions.\n**Chain Pricing**: The core team received a number of requests from key stakeholders to increase pricing of chains to capture more economic value. There was discussion in the forum followed by many discussions between validators, dApp developers, and the core team. Ultimately, a governance proposal was formally submitted and voted on, and the specific outcome was an economic change within a smart contract that changed pricing.\n**Broader Roadmap**: Conversely, product roadmap decisions are made in the same manner Ethereum and Solana make decisions\u2014not by onchain voting. In the case of FAIR, many key stakeholders, including validators, developers, and stakers, brought forward feedback to core contributors that SKALE needed to capture more economic value. A consistent idea brought forward was launching a SKALE ecosystem Layer 1 chain. This was publicly discussed on the forum last November: https://forum.skale.network/t/ideas-from-the-community-the-evolution-of-skale/533.\nBased on the positive feedback, the core contributors had many discussions with dApp devs, validators, stakers, infrastructure partners, and more. The result of these discussions was that the roadmap should include a Layer 1 chain\u2014but it would need to be a true L1 chain in order to give the ecosystem a real opportunity to capture TVL. This meant that the L1 would need its own native token and could not use the bridged SKL token as its genesis token. This is because the highest point of security of the L1 would be the bridge and not the blockchain\u2014if you hacked the bridge, then the entire chain would be compromised.\nA new idea was then brought forward to make the new L1 a dual-token network. This would increase the utility of the SKL token through burning functions in the L1 while enabling the L1 to truly be an L1 that is secured by a native token. This premise was then discussed by numerous stakeholders and contributors, more feedback was integrated, and it was then added to the roadmap and announced in June. It was also announced with the caveat that any changes needing to be made to the SKALE Network smart contracts and core economic functions would first need to be ratified by an onchain vote before being finalized."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: SKALE DAO Initiatives"
        },
        {
          "role": "assistant",
          "content": "### SKALE DAO Initiatives\nThe SKALE DAO is actively exploring a number of key initiatives, which I\u2019ll outline here:\n**SIP-3 Performance Chains**: Already out in the open, SIP-3 is very exciting and I believe nearly ready to bring to the DAO. I\u2019m working with the SKALE team and various potential chain buyers to ensure we are coming in at a price that is both competitive with the broader market while also ensuring that validators are properly compensated for the security they bring\u2014compared to Layer 2s and Layer 3s, which provide no economic security or decentralization.\n**FAIR**: While the roadmap itself falls outside the purview of the SKALE DAO, various future actions regarding the synergy between FAIR and SKALE may come to the SKALE DAO\u2014such as the location of key network components related to economics.\nAdditionally, multiple threads are already open in the SKALE Forum for features and ideas that have been requested by various SKALE developers and teams that are solved by FAIR:\n**Permissionless SKALE Performant Technology**: SKALE is incredibly performant and highly stable. Most of the developers I\u2019ve worked with, once they start using SKALE, don\u2019t want to leave. However, developers have been asking to do things like token launchpads, onchain messaging, permissionless DeFi and token creation\u2014things that don\u2019t align well with the containerized design of SKALE Chains, which are generally not designed to support the level of state that permissionless chains do.\n**Enhanced DeFi with Gas Fees**: While much of blockchain\u2014especially on the EVM\u2014can be done without a native gas token, as proven by the SKALE Network, many DeFi protocols and key infrastructure components build on the native gas token directly, or at least by default support using it and wrapping automatically. I proposed in the forum a gas fee SKALE Chain and it was met with pretty open feedback. I think FAIR\u2014which combines both gas fees and the permissionless blockchain layer\u2014makes a ton of sense toward solving this proposal.\nI believe the SKALE DAO and broader SKALE developer community are in a fantastic position. The next six (6)\u201312 months are going to be an incredible time to get involved on the forum, with the DAO, or come build on SKALE if you are not already. While the above are some of the active initiatives I\u2019m working through currently with various teams in the SKALE Community, there are also a number of other topics that are being researched based on community requests such as offsetting inflation through SKL burning.\nInterested in building on SKALE or contributing to the DAO but not sure where to start? DM me on Twitter, Telegram, or Discord at TheGreatAxios or tag me in a forum post."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: A FAIRer Future"
        },
        {
          "role": "assistant",
          "content": "### A FAIRer Future\nI\u2019m also very excited to share with you a quick update on FAIR and how it fits in with SKALE. I believe FAIR is going to be one of the most important components of helping SKALE succeed both in the short and long term. The following are my opinions from collaborating with SKALE Labs and the NODE Foundation on the design and sharing my goals for this chain:\n#### Solving the DeFi Puzzle\nDeFi and liquidity are both critical factors developers use to evaluate what network to build on or use. Time and time again, we see developers choose blockchains that seem promising on paper\u2014but fall short in practice. The reason? They\u2019re propped up by millions in inactive TVL that doesn\u2019t actually support real usage.\nWhen launched in 2020, SKALE chose to focus on high-performance applications with a focus on gaming due to the unique network design. While it has paid off quite well and allowed SKALE to consistently win developers building games and looking for the fastest blockchain, SKALE has struggled to attract DeFi and TVL.\nFAIR is an opportunity for the SKALE Network to address the value issue by offering a fully permissionless chain where anybody can deploy tokens, RWAs (Real World Assets), stablecoins, NFTs (non-fungible tokens), and protocols\u2014without needing to work through a SKALE Chain owner or operator to attain permission to deploy.\n#### Solving SKALE\u2019s Scaling Block\nWhile there are many blockchains being created today, most of them are really just glorified servers running an EVM. They lack the decentralization, the fault tolerance, and the economic security collateral that a network like SKALE has to offer.\nHowever, two areas that SKALE currently struggles with are operational costs and value capture. With SKALE Manager running on Ethereum and base liquidity being sourced from Ethereum as well, key network operation costs for users can often be $5\u2013$15 in ETH when gas prices are low\u2014and easily stretch into the dozens or hundreds of dollars when gas spikes during congestion. Compute-intensive operations like creating SKALE Chains, which cost over 0.5 ETH (over $1,350 at time of writing), are not feasible for more cost-effective SKALE Chains. Additionally, all gas fees spent on operations are lost to the Ethereum ecosystem and not captured by the SKALE ecosystem.\nFAIR has the opportunity to solve both problems at once\u2014with both cheaper fees (the chain will have a gas token), while also allowing a synergistic chain to capture the revenue spent instead of bleeding to a competitor."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Conclusion"
        },
        {
          "role": "assistant",
          "content": "### Conclusion\nFAIR is the biggest upgrade coming to SKALE, in my opinion, since V2. A true technical innovation that other blockchains just can\u2019t compete with, the native MEV resistance and future privacy features coming with BITE Protocol\u2014alongside the direct benefits that SKALE will attain\u2014are exciting.\nUltimately, my goal is to help bring these ideas to life and contribute what I can to the vision. I can honestly say that everyone I\u2019ve talked to about this is incredibly excited and are using words like \u201cit makes total sense\u201d when hearing about the FAIR and SKALE synergy.\nValidators, developers, and token holders alike are excited\u2014and I\u2019m excited to work with everyone to bring this vision to life."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "This comprehensive guide explores how SKALE Network revolutionizes game development by providing blockchain infrastructure that replaces traditional servers, databases, and storage systems with zero-gas, high-performance alternatives. Supporting 500-13,000 transactions per second with instant finality and native random number generation, SKALE enables developers to build asset-based games, real-time multiplayer experiences, leaderboards, and autonomous worlds while eliminating the cost barriers that make blockchain impractical for gaming on other networks.\nSKALE offers developers solutions to streamline game development, reduce server management costs, and remove scaling challenges. With features like zero gas fees and instant transaction finality, this blockchain network empowers you to create robust multiplayer experiences and manage in-game assets efficiently, keeping your focus on crafting exceptional games.\nA big thank you to Ben Miller, Head of Partner Marketing at SKALE Labs for all his incredible feedback and edits on this detailed blog.\n![](https://cdn-images-1.medium.com/max/1600/1*46VMG7ljY0ZDUG0lmmRuVQ.jpeg)"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Game Development with SKALE"
        },
        {
          "role": "assistant",
          "content": "### Game Development with SKALE\n***\n#### SKALE Primer\nSKALE is a blockchain network home to many Layer 1 blockchains. You can think of a blockchain as a hybrid compute machine \\[kind of like a cloud server] that offers compute and storage to a developer without requiring the developer host the server directly. These machines are operated by 3rd parties known as validators. The term validator comes from \u201csomeone who validates\u201d i.e. the one who is building the chain.\nIf you are familiar with Web3 as a whole, a nice analogy for a SKALE Chain is\u00a0**a mini Ethereum with super powers**. Offering all the capabilities of the first programmable blockchain plus the super powers seen here.\n##### Super Powers of a SKALE\u00a0Chain\n**Zero Gas Fees**\nHistorically blockchains have used fees at the transaction level called\u00a0**gas fees**\u00a0or\u00a0**transaction fees**\u00a0depending on the ecosystem you are in where every\u00a0**write**\u00a0or\u00a0**action**\u00a0costs the sender some amount in fees. Gas fees are one of the most popular pain points for gamers who have a very fair complaint that gas fees prohibit them for focusing on the game.\nSKALE eliminates gas fees entirely with an innovative Blockchain-as-a-Service (BaaS) model.\u00a0Learn more about SKALE Chain Pricing in the SKALE Forum.\n**Instant Finality**\nTraditional databases have instant settlement and finality.\u00a0*What does this mean?*\u00a0When you send a\u00a0**write**\u00a0to \\[most] databases, it takes a single cycle for it to be able to be\u00a0**read**\u00a0back and final in the database. The majority of blockchains do not work this way. They either require many cycles or\u00a0**blocks**\u00a0to become final OR they rely on other chains to prove their finality. This makes them highly inadequate and inefficient for gaming.\nSKALE Chains and the underlying consensus operate in a similar manner to traditional server and database systems. When a transaction is sent on a SKALE Chain it is immediately known whether it will be successful or not. After submission to the chain, it takes a single cycle (i.e. 1 block) to ensure that it is final and will be fully readable back. These blocks generally take around one (1) second, however, they can be even faster as a chain is put under more load.\n**High Throughput**\nEvery computer and software system in the world has limitations. Traditional systems and blockchain systems share many similarities and differences. One of the most common is that reads are more common than writes and so systems are optimized for this. On average, a blockchain will experience a minimum of 5\u201310 reads for every one write due to the amount of calls that are made to access key information needed to execute and check for a transaction.\nSKALE Chains by default are highly fault tolerant by making use of 16 high performance machines operated by 3rd party validators. Each of these machines is easily capable of handling tens of thousands of concurrent requests while simultaneously building the chain through\u00a0**execution of functions and storage of information**\u00a0at a minimum rate of\u00a0**500 calls per second**\u00a0and a theoretical maximum of\u00a0**\\~13,000 calls per second**.\n> For those familiar with blockchain, calls are equal to transactions.\n**Native Random Number Generation**\nRandom numbers are one of the most commonly used features within software development. They are especially prominent within game development. SKALE Chains offer native RNG capabilities directly in Solidity that allow for the\u00a0**infinite creation of provable random numbers**\u00a0to be used for anything the developer sees fit.\nRandom values can be used for map creation, asset allocation, randomized selection, seed generation, and more. SKALE is the only blockchain that offers RNG functionality directly at the chain level\u00a0**for free**. Other chains rely on 3rd party services like Chainlink or Pyth which can be both highly centralized, slow, costly, and complicated to develop with.\n***\n#### Popular Web3 Gaming Approaches\nThe following approaches are some of the most common types of games types and higher level mechanics that make sense to bring onchain.\n1. **Asset-Based Games (e.g., Farmers, Clickers, Strategy Games)**\n   SKALE is ideal for handling in-game assets such as inventory, upgrades, and items in asset-based games. By leveraging blockchain technology, developers can create a transparent, player-owned economy, where players truly own their in-game assets. This opens up new opportunities for trading, crafting, and evolving the game world over time, all while maintaining a seamless player experience.\n2. **First-Person Shooters (FPS) and Real-Time Games**\n   Traditional FPS games rely on local servers for player interactions, typically grouping players based on geographical proximity to reduce lag. With SKALE, developers can utilize decentralized blockchain infrastructure to handle crucial gameplay elements in real-time, such as loadouts, player positioning, statistics, and map configurations. This allows for a more dynamic and interactive experience, especially in large-scale multiplayer games.\n3. **Leaderboards and Rankings**\n   SKALE is well-suited for managing competitive elements like leaderboards and rankings. Blockchain\u2019s immutability ensures that rankings are transparent and tamper-proof, giving players confidence that their achievements are accurately represented and securely stored. Moreover, with SKALE\u2019s scalability, even large-scale leaderboards can be handled efficiently, ensuring that players from all around the world can compete in real-time without lag or delays.\n4. **Player Lobbies and Matchmaking**\n   Managing player lobbies and matchmaking in real-time can be a logistical nightmare for developers using centralized services. SKALE enables decentralized matchmaking systems, where player data and session information are securely stored and easily accessible across a distributed network. This ensures a fair and transparent matchmaking process while allowing for seamless lobby creation and management.\n5. **Massively Multiplayer Online (MMO) Games with Dynamic Economies**\n   MMOs are perhaps the best example of a game type that benefits from decentralized infrastructure. With SKALE, developers can extend their games\u2019 economic systems by enabling decentralized marketplaces, dynamic item economies, and player-driven world-building. The scalability of SKALE ensures that even in large MMO worlds, player interactions and in-game economies can be managed securely and efficiently, without the bottlenecks associated with centralized servers.\n6. **Turn-Based Games**\n   In turn-based games, player moves and game states must be securely stored and shared in a way that ensures fairness and transparency. SKALE enables developers to store turn data and game states on the blockchain, allowing for decentralized decision-making and eliminating the need for centralized server management. This leads to a more player-driven, secure, and transparent gaming experience.\n7. \\*\\*Open and Autonomous Worlds (Minecraft-Style Games) \\*\\*\n   Blockchain technology\u2019s decentralized nature and transparency make it ideal for creating open, player-driven worlds that can be modified, extended, and evolved autonomously. Similar to Minecraft, players in SKALE-powered worlds can develop, build, and create content in a persistent environment where the game\u2019s code and assets are publicly accessible. This allows for community-driven mods, world extensions, and dynamic, player-controlled content. The blockchain ensures that these modifications are secure, transparent, and permanent, fostering a rich, collaborative environment that grows with the community over time.\n***\n#### Development Mechanics\nIn addition to the high level approaches above, there are some lower level mechanics that developers can mix and match when looking to enhance their games with blockchain. The following is designed based on the technology of the SKALE Network since it takes into account critical features such as zero gas fees, instant finality, native RNG, and high throughput.\n##### Digital Collectibles\nArguably the place where Web3 gaming got its start is in the form of digital collectibles, commonly known as Non Fungible Tokens \\[or NFTs] within the blockchain space. These assets come in many different forms however the general goal is to allow assets to be represented on a chain and be owned directly by users.\nThe great part about digital collectibles is from an operational perspective they can be created and used in many different ways including both valuable and in-game only collectibles. Collectibles can also be made non-transferable (i.e. soulbound). Lastly, collectibles can be made incredibly custom to where you can use multiple collectibles to create others or even make a single asset fungible through additional tokenization.\nFor instance if you have collectible items in-game already, these can be converted into digital collectibles and stored on-chain (items, weapons, etc).\n##### In Game Currencies\nIn game currencies are incredibly popular within most games. Blockchain can be used to create both soft and hard currencies with many different flexible mechanics. These can also be specifically modified to guarantee they stay off of exchanges and other \u201ctrading\u201d platforms so that they are only usable within a game, on a specific chain, or within a certain subset of users.\n> One of the nice parts about using digital collectibles or in-game currencies on blockchain is the automation mechanics available. Ensuring that users are paid out rewards or achievements based on something else is very simple thanks to smart contracts.\nYou can learn more about deploying collectibles and in-game currencies with\u00a0Sequence; one of the most popular gaming providers on SKALE.\n##### Efficient Analytics\nThe Ethereum Virtual Machine (EVM) is uniquely designed to be highly efficient at processing and emitting events to many clients in parallel. This can be useful for building programs like leaderboards and lobby systems. The following explores the basics of using the blockchain for analytics and how you can connect that with your game and its players.\nThere are three ways a blockchain can be used for analytics:\n1. The EVM has a specific type of action called an\u00a0**Event**. Events can take many pieces of information and emit them so that they can be listened to by many different clients. Publishing information through events will allow many players or games to share data with each other\n2. Storage in the EVM can be set to public or private by the creator of the program. This means that developers who want to make statistics available to their community for easy access for building modifications, extensions, or DLCs can do so with blockchain. Exposing state through public read only functions will enable others to build smart contracts that can extend and access the information in a safe and secure way.\n3. Onchain analytics are also great for achievement systems. Examples include:\n* Every N number of kills per player in a FPS automatically mint them some special random assets\n* Every N number of some event i.e 1st, 10th, 25th, 50th, 100th, 500th, 1000th,\u00a0\u2026, Nth of every single event -> mint an achievement that is permanent on chain.\nInterested in adding onchain achievements to your game? Contact\u00a0Eidolon Labs\u00a0to work with the experts who built one of the first onchain achievement systems in the form of Untitled Platform.\n##### Blockchain for\u00a0Compute\nBlockchains that have many nodes are very unique in that they act as a unique combination of compute and data storage. However, when comparing them to traditional compute types it\u2019s important to understand that it\u2019s a bit of a hybrid design. For example, there are two common compute types seen in cloud computing today: traditional server based compute and serverless/edge compute.\n**Traditional Servers**\nTraditional servers, often referred to as Virtual Private Servers (VPS), are often considered inefficient for smaller applications that don\u2019t have consistent load over time and ideal for high performance applications and businesses that need consistent compute. SKALE Chains can directly replace traditional server and database requirements thanks to both\u00a0**read**\u00a0and\u00a0**write**\u00a0capabilities.\nThis is ideal for applications and games of all sizes, but especially beneficial for those just starting out. No need to worry about infrastructure, maintaining nodes, securing servers, etc; when the SKALE Chain does it for you. Additionally\u200a\u2014\u200ascalability \\[no pun intended] is one of the most common things even veteran teams struggle with. Going from one (1) server to hundreds during short bursts of high capacity is incredibly complicated.\nDelegating server based actions to a blockchain can help guarantee that you are set up for success. For example, let\u2019s say you want to probably generate a random map for a PVP match (in the multiplayer line of thought), you can utilize some basic data structures like multiple arrays (i.e a matrix) and SKALE RNG to create as many 10x10 grids as you want and return them. Additionally, thanks to computers and storage being in the same place you can optionally take those and link them to a game with the PVP state.\n**Serverless**\nThere is a newer paradigm that has gained a lot of popularity in the last few years. Serverless is the act of not running an explicit server but having executable and lightweight functions that can run at a moment\u2019s notice as close as possible to the user. The idea behind this is that you don\u2019t pay for compute you don\u2019t use and so it\u2019s considered to be very cost effective for projects just starting out. It\u2019s also highly scalable since the \u201cscaling up\u201d portion of the stack is delegated to the cloud provider instead of managed by you. While this might help with scalability, it's common to hear companies that start with serverless switch to traditional long running servers when they hit a certain amount of usage.\n**Blockchain**\nEnter blockchain. Technically, it acts as a hybrid compute option that retains the best parts of traditional servers and serverless. By default it is long running and with SKALE\u2019s unique economic model it\u2019s incredibly cost efficient. However, like serverless it runs across many computers by default (i.e. the SKALE Nodes) who can permisionlessley execute the functions deployed to a chain. This by default gives the blockchain capabilities that allow for both short term cost efficiency and long term scalability all in one.\n##### Multiplayer\nWhile already discussed throughout many of the above approaches and mechanics; blockchain thrives for real time multiplayer gaming when:\n* The blockchain can handle sufficient throughput \\[like SKALE]\n* The blockchain can handle real time requests\n* The blockchain can offer instant finality\n* The blockchain can process highly complex game functions\n* The blockchain can handle a high number of simultaneous connections\n* The blockchain has no fees so that more compute can be done onchain\nWith SKALE hitting all of the needed boxes, multiplayer mechanics is a great way to utilize blockchain as a tool without having to be crypto or Web3.\n##### Blockchain as a\u00a0Database\nIn game development, handling large volumes of data efficiently and at scale is crucial. This typically involves using a combination of\u00a0**databases**\u00a0(SQL/NoSQL),\u00a0**caches**\u00a0(Redis, Memcached), and\u00a0**file storage systems**\u00a0(AWS S3, Google Cloud Storage) to manage game data such as player information, game states, asset storage, and user interactions. However, blockchain technology\u200a\u2014\u200aespecially a blockchain with zero gas fees, huge compute limits (268 million block gas limit), and larger contract sizes (64 KB)\u200a\u2014\u200acan offer a more integrated, secure, and decentralized alternative to these conventional systems.\nTraditionally, databases are used to store game data such as player profiles, game progress, statistics, inventory, and in-game assets. However, blockchain can act as an immutable, decentralized database for these types of data, providing key benefits:\n* **Immutability and Security:**\n  Data stored on the blockchain can be made immutable, meaning it cannot be altered once recorded. This is ideal for critical game data such as player achievements, transaction records, or inventory items. By using blockchain for this purpose, developers can ensure data integrity and transparency without worrying about data tampering or corruption.\n* **Decentralized Data Ownership:**\n  In traditional database systems, data is stored on centralized servers owned by a third party, creating a potential vulnerability. Blockchain, on the other hand, distributes data across a network of nodes, ensuring that players themselves have control over their data. This is particularly important in asset-based games or games that involve unique digital items or currencies (e.g., NFTs), where players want real ownership.\n* **Scalability and High-Volume Data Handling:**\n  With a \\~268 million block gas limit and zero gas fees, SKALE is capable of handling the massive data throughput required by modern games. This allows for the storage of millions of player profiles, inventory data, game stats, and other dynamic data without performance degradation.\n> **Example:**\u00a0In an MMO, players\u2019 inventory data, equipped items, and character stats can be stored on the blockchain. Each player would have a decentralized, immutable record of their assets and progress that could be accessed and verified without reliance on centralized servers.\n##### Blockchain as a\u00a0Cache\nIn traditional game architecture, caches are used to store frequently accessed data (e.g., player profiles, game state, leaderboard rankings) to speed up retrieval times. With blockchain, especially one with zero gas fees like SKALE, this need can be eliminated:\n* **Instant Access to Onchain Data:**\n  Data can be retrieved directly from the blockchain without needing an intermediary caching layer. Since SKALE operates with zero gas fees, developers don\u2019t have to worry about the transaction costs typically associated with writing to the storage layer and reads are always free. Players can access data in real time without the latency or costs of traditional caching systems.\u00a0*Additionally, the use of blockchain sync nodes placed strategically around the world can greatly reduce latency for gamers.*\n* **No More Cache Invalidation Issues:**\n  Traditional caches have to handle cache invalidation (ensuring outdated data is refreshed), which can be complex and error-prone. SKALE data is\u00a0**always up-to-date thanks to instant finality**, and since every transaction or update is public and verified on the chain, there is no need for additional systems to ensure data freshness.\n* **Reduced Need for Expensive Caching Services:**\n  As the need for complex caching systems is removed, developers can save on infrastructure costs. The blockchain itself serves as a dynamic, high-performance store for frequently accessed game data.\n> Example: In an FPS or real-time strategy game, player stats and leaderboard rankings can be stored on-chain and accessed in real time without the need for separate caching infrastructure. The blockchain\u2019s low-cost, high-speed retrieval replaces the need for a dedicated caching system like Redis or Memcached.\n##### Blockchain for File Storage, Replication, and Availability\nGames often require file storage for assets such as textures, 3D models, animations, and other game data. SKALE offers two ways to store assets directly onchain.\n1. **Smart Contract Storage**: while this is technically doable on ALL blockchains; low block gas limits, small contract sizes, and variable gas fees can make this both difficult and costly. SKALE eliminates those barriers allowing text-based files like JSON to be stored directly onchain for free.\n2. **Native Filestorage**: a feature native only to SKALE is SKALE Filestorage. SKALE Chains upon creation can optionally allocate some portion of their nodes to filestorage. This allows files to be uploaded to the chain and replicated across all the nodes and served directly from the blockchain.\nThe following explores in greater depth multiple ways that SKALE can be used to store and serve files.\n* **Smart Contracts as Asset Containers:**\n  Instead of relying on cloud storage solutions like AWS S3 to hold game assets, developers can store these assets directly within smart contracts. SKALE\u2019s large contract size (64 KB) allows for storing more data on-chain, making it a viable option for smaller game assets. For example, textures or small game models can be encoded into the blockchain, ensuring transparency and verifiability. Additionally, many files can be dynamically manipulated on chain so that they can be used in conjunction with other smart contracts to manipulate their data.\n* **Cost-Effective File Storage:**\n  With zero gas fees, SKALE makes storing and accessing game assets on-chain more affordable compared to traditional cloud storage models, where developers are often charged based on the amount of data stored and the frequency of access.\n* **Decentralized CDN:**\n  Traditional CDNs are one of the most solutions developers use to speed up their applications. While boasting incredible speed; CDNs can be very costly. SKALE allows for decentralized file access and availability, reducing the risk of data loss, tampering, or centralization while also enabling CDN capabilities that are pre-paid \\[inclusive of egress charges]\n> **Example:**\u00a0In a collectible card game (CCG), each card could be an asset stored on the blockchain. Instead of storing card images and metadata on external servers, they can be securely stored within the blockchain itself. The card\u2019s metadata (e.g., stats, images, abilities) could be embedded in the blockchain, ensuring transparency, ownership, and ease of access.\n##### Summary\nIf you read this entire article whether in one sitting or many, thank you for spending the time. I hope you learned something valuable and most importantly recognize that the right technology means you don\u2019t have to be a \u201cWeb3\u201d game or launch a token to be a blockchain game. There are many amazing ways to use blockchain and more specifically SKALE to level up your game.\nFor game developers interested in adding blockchain mechanics to your game, head over to the SKALE Indie Game Accelerator at\u00a0https://skale.space/skale-indie-games-accelerator\u00a0to learn more."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'."
        },
        {
          "role": "assistant",
          "content": "This article explores the gasless design behind x402, a protocol for internet-native payments that enables seamless transactions across any web service without the need for API keys or accounts.\nx402 leverages the existing HTTP 402 \"Payment Required\" status code, which indicates that a payment is necessary to access a resource.\nToday, the primary use of x402 is through stablecoins, primarily USDC, which allows payments to move at blockchain speed instead of through traditional financial institutions.\\\nOne key component of USDC is the use of EIP-3009, which enables the transfer of fungible assets through a signed authorization.\nThis article explores **Transfer with Authorization**, forwarding patterns for existing blockchains, new design opportunities for chains like SKALE on Base, and why not all blockchains are created equal when it comes to meta-transaction patterns."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: What is EIP-3009?"
        },
        {
          "role": "assistant",
          "content": "### What is EIP-3009?\nFor those unfamiliar, EIP stands for Ethereum Improvement Proposal. EIPs are a way for the Ethereum community to propose and discuss new ideas for the protocol. EIP-3009 defines a method to transfer fungible assets through signed authorizations that conform to the EIP-712 typed message signing specification.\nThis enables a user to:\n* Delegate the execution and payment of gas fees to another party\n* Cover gas fees in the token being authorized for transfer\n* Perform a series of actions in a single atomic transaction\n* Enable the receiver of a transfer to execute the transfer\n* Create simplified batching mechanics\nAdditionally, one of the key benefits of EIP-3009 is that it **does not** require sequential nonces, making it far simpler to implement and process actions on behalf of a user without worrying about transaction ordering.\n| Feature                       | EIP-3009 | EIP-2612 |\n| ----------------------------- | -------- | -------- |\n| Sequential Nonces             | No       | Yes      |\n| Pre-Approval (approve/permit) | No       | Yes      |\n| Simple Authorization Flow     | Yes      | No       |"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: EIP-3009 and x402"
        },
        {
          "role": "assistant",
          "content": "### EIP-3009 and x402\nThe on-chain transfer portion of x402, in its first version, is built around the use of EIP-3009. While only a few tokens natively support EIP-3009, such as USDC and EURC from Circle and AUSD from Agora, the pattern lends itself well to a \"permit-to-use\" off-chain approach.\nThe flow of an x402 payment is as follows:\n**Alice**: the user or AI agent, the buyer\\\n**Bob**: the web service or another agent, the seller\\\n**Carol**: the facilitator responsible for verifying and settling the payment\n1. **Alice** requests a resource from a web service or another agent.\n2. **Bob** returns a `402 Payment Required` response that includes a list of accepted payment options.\n3. **Alice** chooses to pay in ERC-3009 compliant AxiosUSD on SKALE Base Chain and signs an authorization using EIP-712 for $0.01. **Bob** requests the resource again, including the `X-Payment` header with his signature base64 encoded.\nnote\nWhile this may seem complicated, most of the work is actually done by the facilitator (**Carol**), who handles the majority of on-chain operations.\n:::"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: x402 Across Blockchains"
        },
        {
          "role": "assistant",
          "content": "### x402 Across Blockchains\nThe goal of an open protocol like x402 is to foster adoption and interoperability. The Ethereum Virtual Machine (EVM) version uses EIP-3009 and is extendable across today's ecosystem of many EVM blockchains.\\\nA Solana implementation also exists and will be explored in a future article.\nIt is important to understand the ability to use x402 across blockchains and the ways it can be enabled:\n#### Native ERC-3009 Implementation\nThis is the default and preferred method to implement x402, identical to the Bridged ERC-3009 Implementation discussed below.\\\nThis is how USDC, EURC, and AUSD are implemented on Base and other EVM chains today. While not all tokens are natively ERC-3009 compatible, existing tokens can upgrade if the pattern is supported and the issuer allows it.\nFor tokens that cannot or prefer not to upgrade, the options are ERC-3009 Forwarding or Bridged ERC-3009 Implementation (preferred).\n#### ERC-3009 Forwarding\nERC-3009 Forwarding is a pattern that existed conceptually but had limited implementation until I tested x402 on FAIR Testnet in late September.\\\nFor an example, see my EIP-3009 Forwarder contract.\nnote\nSKALE Expand brings truly gasless x402 to any blockchain ecosystem. The native IMA bridge is one of the fastest liquidity bridges globally, secured by the SKALE Chain consensus. For example, deploying on Base turns SKALE into an app that accrues TVL and supports new EIP-3009 tokens while remaining gasless. Other ecosystems could request SKALE deployment to achieve the same setup.\n:::"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Conclusion"
        },
        {
          "role": "assistant",
          "content": "### Conclusion\nx402 is powerful, and I have been building on it for a couple of months now. Combining x402 with ERC-8004 trustless agents on a blockchain designed for the machine economy presents exciting possibilities.\nExpanding that further into the broader world of agentic systems and the machine economy I think there is a massive opportunity to bring many businesses and people onchain.\nReach out if you are building on x402 or ERC-8004 and want to collaborate, share ideas, or just get some feedback on your project."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers."
        },
        {
          "role": "assistant",
          "content": "As the agentic economy emerges and AI agents begin transacting at scale, the infrastructure we choose for these economic interactions will determine whether machine-to-machine commerce thrives or stalls. While the conversation often centers on payment protocols like x402, there's a more fundamental question that gets less attention: **What is the actual cost of enabling billions of agentic transactions?**\nThere is a hidden cost today to agentic commerce running onchain with x402 rails. What is it? Variable Costs.\n:::note\nThe hidden cost isn't the payment protocol or the integration complexity\u2014it's the unpredictability of transaction costs at scale. When agents transact billions of times daily, variable gas costs and surge pricing make economic models impossible to predict.\n:::\nThere are always complaints about how traditional PSPs are so expensive i.e. the 2.x% + some amount of cents (e.g $0.3) which can result in many software sellers and physical merchants putting minimums on payments with a credit card, such as $5.\n|                    | Traditional PSP       | EVM Chains                  | Solana                              | SKALE                        |\n| ------------------ | --------------------- | --------------------------- | ----------------------------------- | ---------------------------- |\n| **Base Cost**      | 2.x% + $0.30 per tx   | Gas token value \u00d7 gas used  | Priority fee \u00d7 compute units        | Pre-paid credits (fixed)     |\n| **Predictability** | Fixed per transaction | Variable (token + capacity) | Variable (local fee markets)        | Fixed until expansion needed |\n| **Under Load**     | Same cost             | Global surge pricing        | Local surge pricing on hot accounts | Add capacity, no surge       |\n| **Finality**       | Days (settlement)     | Minutes to hours            | \\~12-15 seconds                     | \\~1 second                   |\n| **Best For**       | Large transactions    | Occasional use              | High-frequency single-app           | Agent-to-agent scale         |\nBlockchains historically have used a valuable gas token that has brought two levels of variability toward the cost of consuming block space:\n#### 1. Asset Value Variability\nThe price of the gas token goes up, it just became more expensive for all parties to participate.\n#### 2. Capacity-Based Surge Pricing\nThe capacity of the chain itself leads to surge in pricing as the chain protects itself against overuse by raising the gas price. This in turn makes it harder or more expensive to land transactions and generally has worked as a deterrent where most non-power users go elsewhere or trickle down to cheaper blockchains (historically)."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Why SKALE Makes Sense for x402 Merchants"
        },
        {
          "role": "assistant",
          "content": "### Why SKALE Makes Sense for x402 Merchants\nWhy does SKALE make so much more sense for merchants and facilitators as the primary location to accept x402 payments in stablecoins and cryptocurrency?\n#### The Credit System: Predictable Costs\nSKALE Base, the first chain in SKALE's new expand program, uses a credit system that is backward compatible with EVM gas fees. This solves No. 1 from above by reducing variability in acquisition of compute resources. This aligns with how more traditional cloud providers rent resources in exchange for a flat fee. If 100,000,000 developers turn around and want to run OpenClaw bots on AWS t3.medium EC2 instances; I personally have never seen AWS surge price their instances.\n#### Surge Protection Without the Pain\nThe second point is more nuanced. SKALE has the same protection that other blockchains do in regards to surge pricing. The differences?\n**a. Higher Compute Thresholds**\nHigh performance chains with massive compute limits (compared to traditional EVM) are capable of handling a much higher load before seeing the protective increase. This makes it easier to avoid small, choppy surges that can be painful on your wallet.\n**b. Horizontal Scalability**\nThe part that is truly powerful is the horizontal scalability. This is how cloud giants maintain (and often are actually able to make prices cheaper over time). The ability to continuously supply more and more compute means there is no cap when demand starts to grow; like we often see with other chains."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: How does this work?"
        },
        {
          "role": "assistant",
          "content": "### How does this work?\nSKALE is natively multi-chain through an application called SKALE Manager which is a set of smart contracts deployed on Ethereum (SKALE Ethereum) and Coinbase's Base L2 (SKALE Base). The smart contracts have a pool of validator Supernodes registered to them which in turn are used to dynamically provision SKALE Chains when the smart contracts ask for them.\nWith the new credit system, it's possible that as the agentic economy begins to grow agents themselves will buy SKALE Chains directly and continue to add support for more chains to keep their costs to a minimum and maximize profit."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: The Economics of Expansion"
        },
        {
          "role": "assistant",
          "content": "### The Economics of Expansion\nThis model isn't unique to blockchain infrastructure\u2014it's how successful businesses scale in the physical world as well.\n#### Physical Retail Expansion\nConsider a grocery store that reaches capacity during peak hours. They don't surge price their milk when the checkout lines get long. Instead, they open more registers, expand their footprint, or open new locations. The upfront cost of expansion pays dividends in the form of captured demand that would otherwise go elsewhere.\nThe store that expands when demand rises captures the growing market. The store that stays fixed-size loses customers to competitors who can serve them.\n#### Cloud Provider Economics\nThe same logic powers AWS, Cloudflare, and other cloud giants. When demand spikes, they don't just raise prices\u2014they provision more servers, build new data centers, and expand capacity. This allows them to:\n* Capture growing demand rather than turning customers away\n* Economies of scale that often let them *lower* prices over time\n* Provide predictable pricing that attracts long-term customers\n#### SKALE's Expansion Model\nSKALE operates on this same principle. When agentic transaction volume grows, the network can provision additional SKALE Chains to handle the load\u2014without surge pricing that would drive users away.\nFor merchants and facilitators building on SKALE, this means predictable costs at scale. The infrastructure grows *with* your business, not against it."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Conclusion"
        },
        {
          "role": "assistant",
          "content": "### Conclusion\nThe agentic economy will be built on infrastructure that can handle billions of transactions predictably. Variable costs\u2014whether from gas token volatility or capacity-based surge pricing\u2014are a hidden tax on agent-to-agent commerce that makes economic modeling nearly impossible.\nSKALE's credit system and horizontal scalability offer a path forward: predictable costs that scale with demand, not against it. Like cloud providers and successful retailers, the winning strategy is expansion, not extraction.\nAs I explored in The Role of Pay-Per-Tool in an Agentic World, the future of agentic systems depends on infrastructure that can scale sustainably. SKALE provides that foundation for x402 payments.\nx402 on SKALE, DM me and I'll help you integrate."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "This article explores SKALE Network's native random number generation system that uses threshold signatures from consensus nodes to create provably random numbers at zero gas cost. Unlike external oracles like Chainlink VRF, SKALE's RNG is free, synchronous, and built directly into the blockchain, enabling developers to generate unique NFT attributes and implement innovative game mechanics like Shape Storm's single-ownership roguelike where players can only hold one randomly-generated shape at a time.\nShape Storm by Eidolon is a rougelike that uses the blockchain for optional ownership and analytics. As rougelikes are heavily on randomization it was a natural fit to explore using the blockchain for provable randomness. SKALE offers a native random number generation endpoint that allowed the Eidolon team to take Shape Storm to a whole new level by having all the core attributes from players shapes be randomly generated on-chain and stored as as a playable NFT. This also lends itself to a future exploration of survival mechanics with upgradeable random values.\nAdditionally, the unique random values lends itself to the single-ownership system where a user can only own a single NFT from Shape Storm at a time. They can choose to send it elsewhere or remove it, but if they get rid of their current shape there is no guarantee the next one will be better.\nRead on for a deep dive into RNG on SKALE and the implementation within the Shape Storm smart contract.\n***\n#### SKALE RNG\nEvery\u00a0SKALE\u00a0Chain has a random number generator contract pre-compiled and available. A new random number is generated for every block based on the threshold signature of that block. As SKALE Chain consensus is asynchronous and leaderless the blocks must be signed by at least 11/16 nodes \\[on the SKALE Chain]. The signature from each node is glued together so that single node can influence the resulting signature. This process ensures that the results cannot be manipulated by a single entity.\nThe process for actually attaining the random number generation looks like this:\n1. The signatures for the current block are retrieved\n2. The BLAKE3 hash of the signatures is created\n3. The resulting hex RNG is presented and consumable in Solidity\nAs it is available through a pre-compiled contract on every chain, a major advantage of this compared to a 3rd party RNG generator like\u00a0Chainlink\u2019s\u00a0VRF is that the random number is directly available as a read and does not need to be set/shared/consumed in a callback or require additional payment. It\u2019s free as gas fees on SKALE are 100% free!\n> *A quick reminder that SKALE RNG only works on SKALE.*\nThe function in Solidity looks like this:\n```solidity\n// Reminder, this is Solidity (.sol)  \n// SPDX-License-Identifer: MIT  \npragma solidity ^0.8.13;  \ncontract A {  \n    function getRandom() public view returns (bytes32 addr) {  \n        assembly {  \n            let freemem := mload(0x40)  \n            let start_addr := add(freemem, 0)  \n            if iszero(staticcall(gas(), 0x18, 0, 0, start_addr, 32)) {  \n              invalid()  \n            }  \n            addr := mload(freemem)  \n        }  \n    }  \n}\n```\n#### RNG Package\nThe above code, while simple enough to use for a single random number, requires some additional work to generate\u00a0**many**\u00a0random numbers in a single function. To make this easy to consume,\u00a0Dirt Road Development\u00a0has created a utility package called\u00a0skale-rng. This NPM package can be added to your codebase and offers a number of pre-built utilities to quickly iterate on the RNG value to grab many random numbers. It also helps with selecting and maintaining ranges for the random numbers.\n#### Shape Storm &\u00a0RNG\nIn the code below you will notice a few things:\n1. The first use of random number value is\u00a0**getRandomRange(4)**\u00a0where the value is then ternary checked to ensure that it is never 0. This is because with 0 being the default \u201cempty\u201d value in the EVM it made more sense to start at 1 for this array. Based on that the number is expected to be between 1\u20134.\n2. After this you will notice the next function used is\u00a0**getNextRandomRange(X, Y).**\u00a0This function was chosen to ensure that the one random number in the block could be \\[bitwise] operated on and re-hashed to generate more random numbers. The X value can be any number that some bitwise action will occur on in relation to the original rng value in order to generate a new integer which can be hashed and re-cast to a uint256 in order to give us a new random number. The Y is the maximum value in-range (inclusive). This function is used over and over to generate a whole bunch of random numbers\u200a\u2014\u200aat no cost\u200a\u2014\u200aall in one shot.\nThe end result of this is that every shape is represented as a unique NFT in ERC-721 format!\n```solidity\n// Reminder, this is Solidity (.sol)  \n// SPDX-License-Identifer: MIT  \npragma solidity ^0.8.13;  \ncontract ShapeStorm is RNG {  \n  function _mint(address to) internal {  \n        uint8 rng = uint8(getRandomRange(4));  \n        uint8 shapeNumber = rng == 0 ? 1 : rng;  \n        if(currentTokenId + 1 > maxTokenSupply) revert MaxSupplyReached();  \n        ShapeStats memory baseShapeStats = baseStats[shapeNumber];  \n        uint8 rotateSpeed = _validateNumber(MINIMUM_ROTATE_SPEED, uint8(getNextRandomRange(3, baseShapeStats.rotateSpeed)));  \n        uint8 maxSpeed = _validateNumber(MINIMUM_MOVEMENT_SPEED, uint8(getNextRandomRange(4, baseShapeStats.maxSpeed)));  \n        uint8 dashSpeed = _validateNumber(DASH_SPEED_BOOST, uint8(getNextRandomRange(5, baseShapeStats.dashSpeed)));  \n        uint8 bulletDamage = _validateNumber(BULLET_DAMAGE, uint8(getNextRandomRange(6, baseShapeStats.bulletDamage)));  \n        uint8 shootCooldown = _validateNumber(SHOOT_COOLDOWN, uint8(getNextRandomRange(7, baseShapeStats.shootCooldown)));  \n        uint8 shieldCapacity = _validateNumber(SHIELD_CAPACITY, uint8(getNextRandomRange(8, baseShapeStats.shieldCapacity)));  \n        uint256 newTokenId = currentTokenId++;  \n        tokenStats[newTokenId] = ShapeStats(baseShapeStats.shape, rotateSpeed, maxSpeed, dashSpeed, bulletDamage, shootCooldown, shieldCapacity);  \n        _safeMint(to, newTokenId);  \n  }\n}\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples."
        },
        {
          "role": "assistant",
          "content": "This article examines how blockchain infrastructure, particularly SKALE Network's zero-gas, high-performance platform, will enable the emergence of a machine-driven economy powered by autonomous AI agents. By combining technologies like x402 for programmable payments, small language models for efficient AI processing, and decentralized identifiers for verifiable interactions, we can create seamless workflows where machines transact, collaborate, and execute economic activities without human intervention."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: What is SKALE?"
        },
        {
          "role": "assistant",
          "content": "### What is SKALE?\nSKALE is a network of Ethereum-compatible blockchains designed for speed, efficiency, and scale. It offers zero gas fees, native multi-chain functionality, and a high-performance Ethereum Virtual Machine (EVM) implementation built in C++.\nWhat makes SKALE unique is the range of features built directly into the network. Developers get onchain random number generation (RNG), a native oracle, a fully decentralized bridge connecting Ethereum and SKALE Chains, and onchain file storage\u2014all without relying on external services. These features make SKALE a true decentralized cloud for compute and storage.\nOn top of that, SKALE delivers the only single-slot finality EVM in production today. Consensus is mathematically provable, fully asynchronous, and leaderless, allowing transactions to finalize in about a second with strong security guarantees. This combination of speed, scale, and native capabilities sets SKALE apart as one of the most advanced blockchain platforms available today.\n**ELI5 Analogy:**\u00a0Imagine Ethereum (and most L1s and L2s) are like busy cities with one main highway. SKALE builds an entire network of highways that are just as safe but much faster, and every car on them gets free gas. Not only that, each highway comes with built-in tools like storage garages, toll-free bridges, and even random dice rollers for games. It's like giving blockchain apps their own superhighway to run smoothly without traffic jams.\n#### A Focus on Compute\nSKALE set its sights on being home to\u00a0**high-performance, compute-intensive decentralized applications**, especially in areas like onchain gaming, DePIN, and real-time data processing.\nThe screenshot below is from dAppRadar-- one of the leading data and analytics platforms in the blockchain space -- on 8/22/25 and shows that 3 of the top 5 games in blockchain are on SKALE. If you double click into each you will see that all three do a significant amount if not the majority of their compute on SKALE.\n!dappradar-top-5-games-8-22-25\nThe architecture\u2014featuring customizable, zero-gas chains with high throughput and low latency\u2014makes it the go-to blockchain platform for apps that literally live in the world of millions of transactions. The above dApps are built across the Nebula and Calypso SKALE Hub Chains.\nWhen people talk about SKALE being built for heavy workloads, the best example is\u00a0**Exorde**. Exorde is a decentralized data and sentiment-analysis protocol that depends on millions of transactions every single day. Contributors across the world continuously crawl tens of millions of URLs and submit data to the chain, which translates into\u00a0**over 2 million daily transactions**\u00a0and nearly\u00a0**1,000,000,000 (billion) total transactions**\u00a0onchain so far. On any gas-metered chain this level of activity would cost hundreds of millions of dollars, making the model completely unsustainable. On SKALE, those same transactions are processed at\u00a0**zero gas cost to users**.\nThis isn't just a matter of being \"cheaper.\" Without SKALE's zero-gas model, Exorde simply could not exist in a decentralized way. Running millions of writes per day would be financially impossible on Ethereum mainnet or even on most L2s, where gas adds up fast. What SKALE provides is effectively a decentralized compute cloud that can handle workloads which are normally reserved for centralized servers. It shows that SKALE's architecture isn't just optimized for high throughput\u2014it unlocks entirely new categories of applications that only make sense when gas costs are removed from the equation.\n#### The Blockchain Wars\nOver the past 6-12 months the blockchain wars (yes I'm calling it that) have really been heating up. The number of blockchains that have either been announced or launched is continuing to increase. In addition, there are more Rollup-as-a-Service (RaaS) providers and more application-chain networks being spun out, including Base Appchains.\nTime for some opinions. These are my personal opinions and do not reflect the stance of any of the companies I am contracted by.\n**#1 - Most blockchains will die. Most tokens will die. Those that will succeed need differentiation. Speed is not differentiation.**\n**#2 - Layer 2s will continue to be cannibalized by Base and Ethereum scaling the L1 will kick-off a max extinction event for L2s**\n**#3 - Big Layer 1s that are just forks of Geth, have slow consensus, and are racing to the bottom for cheaper fees will all die.**\nA summary of my opinions and why they matter. The majority of blockchains you see today have no usage. Appchains on average have even less usage with many going unused for weeks, months, or even years at a time.\n#### Who will buy Appchains?\nI think that the biggest buyers of application chains over the next 5 years will be large corporations and governments. With compute becoming cheaper, it's feasible for a company to have a fleet of blockchains doing different things, in different locations, with different ownership structures, and different access points.\nA fantastic read from Toyota, this research report dives into how they are planning to use multiple Avalanche subnets to coordinate identity, information, payments, and data. While they are choosing to use Avalanche for their Proof-of-Concept they call out the following as important:\n\"We chose Avalanche because its design centered on multiple L1s (formerly Subnets), its fast finality, and its native ICM align with MON's philosophy of *building locally, collaborating globally.*\" -- Toyota Blockchain Lab%2C%20its%20fast%20finality%2C%20and%20its%20native%20ICM%20align%20with%20MON's%20philosophy%20of%20building%20locally%2C%20collaborating%20globally.)\nBased on the above, SKALE is and will remain a top contender thanks to being the only multichain network with instant finality and zero gas fees that also has sustainable mechanics."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Collaborative Technologies"
        },
        {
          "role": "assistant",
          "content": "### Collaborative Technologies\n#### What is x402?\nx402 revives the HTTP 402 \"Payment Required\" status and turns it into a painless, real-time payments system using stablecoins. It was introduced by Coinbase to enable internet-native payments. It allows APIs, agents, and applications to transact without juggling API keys or subscriptions. Think of it as embedding payments directly into the web with zero friction\u2014no fees, instant settlement, and blockchain-agnostic at its core.\nIf you want to dive deeper, check out this research paper on multi-agent economies. It explores how autonomous agents can use X402 for discovery and payments, enabling seamless HTTP-based micropayments backed by blockchain.\n#### What are Small Language Models (SLMs)?\nWhen I talk about SLMs, I'm talking about the smaller, lighter versions of big language models. They're compact, fast, and cheap to run, but still surprisingly capable. Because they don't need massive cloud compute, they're great for things like edge devices, personal assistants, or any use case where privacy matters. They're basically a practical way to get a lot of AI power without the huge overhead.\nThey retain the general capabilities of LLMs. For this reason, it makes sense that as individuals and companies look to gatekeep resources, APIs, MCP-access, agent-access in order to either profit or at a minimum ensure they are covering costs; SLMs could be a huge unlock offchain.\nI do believe there is the potential to explore running SLMs on SKALE Chains directly as well, but I'll cover that in a different write-up.\n#### What is DID?\nDecentralized Identifiers (DIDs) are, I think, a missing piece of the puzzle to connecting blockchain to the broader internet. Years ago when I was building Lilius, it was one of the areas we were doing heavy research and exploring to help bolster user identity.\nThere has been a significant amount of research and growth in this area:\n* https://ethereum.org/en/decentralized-identity/\n* https://github.com/decentralized-identity/ethr-did-resolver\n* https://github.com/uport-project/ethr-did-registry\nOne of the outstanding questions with both x402 and agentic collaboration is identity and proving. With SKALE's zero gas fee nature, storing DIDs onchain could be done in some cases for free and in others for flat rates (to avoid DoS attacks)."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: A Machine-compatible Future"
        },
        {
          "role": "assistant",
          "content": "### A Machine-compatible Future\nThis section will read a bit like a movie. Let's start with the ending.\n**Blockchains are built for machines, not people. A decentralized and easy UX that isn't bad is nearly impossible to come by and not feasible for the average human being.**\nThe broader positioning of blockchain is very interesting. Over the years the \"pitch\" to the average user has combined ideas like **own your own money** and **be your own bank** to **blockchain is the next version of the internet, i.e Web3**.\nI think the latter has always been the area that was more interesting to me. Building applications for the traditional *Web2* world can at times be very frustrating due to the large number of hoops a developer has to jump through to access information, payment rails, etc. Additionally, many things in Web2 that a developer needs to make a successful application have a high cost of either entry or use.\nThe perfect example is payment processing, which often times charges 2.3% + $0.30 minimum to process transactions or private application stores like Apple, which have historically charged 15-30% on transactions.\nThe promise of blockchain to a developer is the ability to side-step many of these hidden fees and linear costs in favor of something more equitable to both you and your users.\n#### The Pitfalls\nBlockchains are built for machines, not humans, and that creates some real headaches for developers and users alike.\n1. **UX Friction** \u2013 Wallets, gas fees, confirmations, and failed transactions make even simple interactions frustrating. Humans usually just want to click a button and see instant results, but blockchains make this difficult.\n2. **Cost Barriers** \u2013 Transaction fees and the overhead of smart contract execution can make small-scale applications prohibitively expensive. Even simple micropayments or automated interactions become costly if you're relying on general-purpose blockchains with variable gas fees.\n   > FAIR is not grouped in the general purpose category directly for me in the sense of cost barriers because of its inherent differentiation with Proof-of-Encryption. I'm willing to pay a premium for enhanced security on a general-purpose L1.\n3. **Complexity in Automation** \u2013 If you want agents or APIs to act autonomously, you quickly run into problems. Without verifiable credentials, you have no proof that actions were executed by the right system. Without programmable money, you have no way to allocate funds to machines or automate workflows without constant human oversight, considering that traditional payment rails cannot settle instantly and often charge dozens to hundreds of basis points per transaction.\n4. **Security Risks** \u2013 Autonomous systems can behave unpredictably or \"hallucinate\" in edge cases. Without immutable guardrails, you risk agents misallocating funds or performing unintended actions.\n5. **Slow Interoperability** \u2013 Moving value or data between chains or off-chain systems can be slow and expensive, making it hard to scale applications that rely on multiple networks or financial platforms.\n#### My Blue Sky Future\nNow imagine solving these problems with a stack of modern tools and a little architectural elegance:\n1. **Seamless UX for Humans and Machines** \u2013 Humans continue to interact via a simple browser or app interface, while machines (agents, APIs, MCP servers) interface directly with **SKALE** and **FAIR**. Humans never see the complexity, but autonomous agents can execute actions, settle payments, and respond in real-time.\n2. **Verifiable Actions via DIDs** \u2013 Each agent or API can carry a **Decentralized Identifier (DID)** with verifiable credentials. This proves that every action\u2014whether a payment, API call, or task completion\u2014was executed correctly and securely, creating trust without intermediaries.\n3. **Tokenized Workflows with x402** \u2013 With **x402**, payments and tokens flow seamlessly between humans and machines and machine-to-machine. Onramps, exchanges, and an expanding variety of stablecoins allow unique allocation strategies: your AI agent can earn, hold, and spend money autonomously while staying under human-enforced rules.\n4. **Immutable Guardrails on SKALE** \u2013 Smart contracts on SKALE can enforce spending limits or rules for machines (agents, APIs), preventing accidental \"hallucinations\" or misallocations. APIs and traditional servers can automatically receive payments, then dynamically route funds back to agents or financial applications. The reason SKALE shines here is **instant finality and zero gas fees**, letting agents operate continuously without bottlenecks.\n5. **Expanded Financial Access with FAIR** \u2013 Suppose your agent or MCP server earned $1,000 today through x402 payments. With FAIR L1 integration, those funds can instantly be deposited into a decentralized AMM, lending platform, or other financial service\u2014turning autonomous work into real, deployable capital in real time.\nThis is the vision of a **machine-compatible future**: humans enjoy smooth experiences, agents act autonomously but verifiably, and money and data flow instantly and securely across decentralized networks. By combining DIDs, SLMs, x402, SKALE, FAIR, and MCP servers, we can finally build applications where humans, AI, and financial systems interact seamlessly\u2014without friction or unnecessary intermediaries."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Conclusion: Appchains for the Machine Economy"
        },
        {
          "role": "assistant",
          "content": "### Conclusion: Appchains for the Machine Economy\nThis brings us to the inevitable conclusion. The future of blockchain is not a single, congested superhighway but a sprawling, interconnected network of specialized application chains. As the internet evolves into a truly machine compatible ecosystem, the demands on this infrastructure will be relentless. Autonomous agents running on SLMs will need to transact millions of times a day, verified by DIDs and settled instantly via protocols like x402. For these systems, gas fees are not just a cost; they are a critical point of failure.\nThis is where SKALE's architecture transitions from a competitive advantage to a fundamental necessity. Its zero gas, instant finality model is not merely a feature, it is the native habitat for high frequency, compute intensive applications. The very multi chain design that a company like Toyota seeks for its complex data and mobility ecosystems is the core principle SKALE has already perfected.\nAs enterprises and developers move beyond speculation and begin building the high throughput applications of tomorrow, they will not be looking for the cheapest chain, but the only one where their business model is economically viable. SKALE is not just a contender in the appchain race; it is the logical endgame. It is the decentralized cloud where the machine economy will finally be built."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'."
        },
        {
          "role": "assistant",
          "content": "The role of agents and AI tooling is expanding very quickly. With\nnew releases, tools, models, and innovations coming out every day, it's important to understand the role of tools in agentic systems and why the consumption model may be in need of an economic change. This blog introduces the concept of a tool, walks through an example of a tool, and explores why pay-per-tool is the next logical step."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: What is a tool?"
        },
        {
          "role": "assistant",
          "content": "### What is a tool?\nTools are software designed to perform a specific task that are designed to be called by language models. A tool can provide access to complex programming logic, external APIs, or even other models.\nOne of the more common tools that is used across many agentic applications is the ability to search the web. With models being trained on specific sets of data, they tend to have a *cutoff date*, which is when the information used to train the model was last updated.\nThis means that for an LLM to have access to the most recent information, it needs to be able to crawl the web and retrieve up-to-date info.\nLooking at OpenAI, their standard set of tools includes web search, calling to remote MCPs, file search, image generation, code interpreter, and more.\nIn summary, tools are a critical component of agentic systems that allow large and small language models to have access to more information and functionality that may not be available in the model directly."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Why is Pay-Per-Tool the next logical step?"
        },
        {
          "role": "assistant",
          "content": "### Why is Pay-Per-Tool the next logical step?\nAs AI continues to grow in both complexity and usage, a major question is the cost of services and information. It's no secret that the cost of operations for artificial intelligence is enormous, with a significant amount of subsidization and free usage being offered by many of the top companies.\nHowever, as the technology continues to mature and become more mainstream, specifically mainstream for agentic use cases beyond prompt-based LLMs like ChatGPT and Claude, there is a need for agents to have access to more functionality and information\u2014but at whose expense?\nCloudflare introduced pay per crawl to address the changing landscape of consumption. While the motives were slightly different, the end goal is the same: to allow compensation for access to resources.\nThe next logical step is to explore a high-level view of how pay-per-tool covers a number of tools and how it can be used to create a more dynamic and scalable agentic system."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: How does Pay-Per-Tool work?"
        },
        {
          "role": "assistant",
          "content": "### How does Pay-Per-Tool work?\nPay-per-tool is a concept or view of how a simple flow of an agent calling a tool pays for the resource and the provider of the resource receives compensation.\nUsing x402, tools can be paid for per use. This means that the user only pays for the tool they use rather than signing up for hundreds of subscriptions. Additionally, this allows tooling providers to properly pass on the costs as the internet changes and pay-per-crawl becomes a reality.\n!Flow of Pay-Per-Tool\nMore specifically, pay-per-tool is already being explored through a number of open protocols, including the Agent Payment Protocol from Google, x402 from Coinbase, and Agentic Commerce Protocol from OpenAI and Stripe."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: x402: The Default Solution for Pay-Per-Tool"
        },
        {
          "role": "assistant",
          "content": "### x402: The Default Solution for Pay-Per-Tool\nx402 is the internet-native payments protocol from Coinbase that is designed to work within the traditional internet by utilizing the mostly (previously) dormant HTTP 402 status code for `payment required`.\nThis allows existing web services like APIs and websites to easily adopt the protocol and start charging for access. We have already seen x402 explored in collaboration with other protocols like AP2 from Google and the ERC-8004 trustless agents framework being put forward by the Ethereum Foundation.\nThe reason I believe x402 is so key and will play such a big role is a combination of the simplicity and extensibility of the protocol itself. The current design has already allowed a number of services providing tools for agents like Firecrawl and Freepik to start enabling agentic access without the need to build a new API or develop a complex payment system."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Blockchain Scalability and Costs"
        },
        {
          "role": "assistant",
          "content": "### Blockchain Scalability and Costs\nOne of the larger value propositions that x402 brings to the table is the ability to have payments move at the speed of blockchains instead of traditional financial institutions. In reality, even Ethereum with \\~12-minute finality is still faster than most traditional credit card payment settlement and ACH/cross-border processing times.\nAs you start to explore alternative Layer 1 blockchains like Solana, the speed of settlement becomes even more apparent with \\~12\u201315 seconds of finality.\nMy belief is and always will be that the fastest will never be good enough and will always be too slow. As more entities begin utilizing blockchain infrastructure for their operations, the speed of settlement will only continue to decrease.\nBased on the above, the best blockchain in the world today for real-time payments, especially for agentic micropayments, is SKALE.\nWith instant single-slot finality, consensus is completed in just a single block that is processed and executed in around one second on the current architecture. This can be sped up by improving consensus, resizing chains, changing node location (see Hyperliquid), and even improving hardware of the nodes.\nHowever, even if all of that were to be done (see Solana), the speed of settlement is still not enough, with the costs of agentic tools needing to be valued to the tune of billions of requests per day.\nThe words \"it's cheap enough\" have been spoken by teams building on blockchain for the last 5+ years and have so far proven true. Why? Outside of the occasional spike, the costs of operations have been consistently good enough for current use cases to the tune of hundreds of transactions per second.\n#### A Scalability Scenario\nCloudflare, as of 2023, was serving 46 million HTTP requests per second according to Alex Bocharov's blog post.\nBreaking this down, let's assume 0.01% of these requests are agents searching the web. This would equate to 4,000 requests per second\u2014fully capable of being handled by a single SKALE Chain.\nUsing an arbitrary cost of 70,000 gas units per micropayment, the expected block gas limit would need to be at least 280,000,000 gas units per block (just to cover the consumption of the micropayments) excluding any other usage. SKALE, having one of the largest block gas limits at \\~268,000,000 gas units per block, would be able to handle this with ease just by bumping the gas limit slightly.\nMost EVM chains tend to limit the gas limit to \\~30\u201350 million gas units per block, as they lack the capacity to handle this amount of compute.\nAdditionally, with most blockchains being designed to increase the base gas fee per block as the demand for compute increases from block space being filled, the cost of operations would continue to spike and stay elevated on most blockchains under this type of load.\nEven Solana, with local fee markets, would see elevated costs due to constant interaction with specific accounts.\nSKALE, on the other hand, operates more like a decentralized cloud provider\u2014offering pre-paid compute resources and the ability to quickly add more compute to handle spikes in demand. SKALE is capable of handling the above scenario with zero spikes in cost due to the pre-paid nature of the network.\nThis means that while other networks would come to a standstill and see massive volatility and potential stability issues, SKALE would be able to handle the needed load to serve a significant portion of the onchain settlement of micropayments via x402 for agents on just a single SKALE Chain.\nAdditionally, SKALE is almost able to add an infinite amount of SKALE Chains. This means that as more agents come online, more chains can be procured to handle the ever-increasing demand. Forty million requests per second could be handled by 4,000 sChains, each serving 10,000 requests per second.\nWith thousands or even tens of thousands of servers in data centers and locations from many providers scattered all over the world, this is an incredibly feasible scenario for SKALE to be positioned to handle for the agentic world.\n#### Reducing Costs to Increase Demand\nOne of the biggest challenges facing the adoption of pay-per-tool is the cost of operations combined with onchain costs and limits. With gas fees on chains like Solana and Base\u2014both of which are two of the more popular x402 chains today\u2014being around \\~$0.001 for a single transaction, that is close to 15% of the actual cost of the payment being around $0.01, which is the most common cost for an x402 payment today.\nThis is a major barrier to entry for many providers and users alike. The cost of operations is too high, and the onchain costs are too high.\nWith the reduction or removal of gas fees, the cost of operations can be scaled down significantly. This is especially relevant for many x402-enabled endpoints that are currently being used to serve basic content like images, text, price feeds, and more that can arguably cost a fraction of a penny to serve.\nBy scaling the costs down, agents can now afford to do more without the fear of running out of funds or being throttled by the human-set budget.\nWith zero gas fees and instant finality, the cost of operations can be scaled down to literally one wei on a SKALE Chain in any token, with far more complex settlement and management contracts."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Conclusion"
        },
        {
          "role": "assistant",
          "content": "### Conclusion\nThe future of agentic systems is looking bright, but the cost of operations and the ability to scale is a major concern. The vision of pay-per-tool is key to ensuring that the future of agentic systems is capable of scaling to meet the needs of the growing market while being built in a way that is sustainable for providers and users alike.\nIf you are interested in deploying your own MCP server, agent, or resources for the agentic world on SKALE, reach out to me with the information below.\n**Co-authored by Sawyer Cutler and Anthony Holley** <br />\n*May 4, 2026*"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples."
        },
        {
          "role": "assistant",
          "content": "Imagine you're at a drive-thru. You roll down the window and the order taker asks what you want. You could say:\n> \"I would like to order one hamburger, and the hamburger should have lettuce on it, and it should also have tomato, and could you please add cheese, and the bun should be toasted, and I'd like a medium fries, and the drink should be a Coke, and the Coke should be large.\"\nOr you could say:\n> \"Number 3, combo, large Coke.\"\nSame order. Same food. Way fewer words.\nThat's what this project is about. **ai-sdk-wire-middleware** is a middleware for the Vercel AI SDK that teaches models to order their tool calls like a number 3 combo instead of spelling out the full itemized receipt. The result? Fewer tokens, faster responses, lower costs \u2014 and **5\u00d7 better task completion on complex multi-step agents**.\nLet me explain why that matters."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: LLMs Speak In Tokens"
        },
        {
          "role": "assistant",
          "content": "### LLMs Speak In Tokens\nFirst, a quick primer. LLMs (Large Language Models) don't read words like we do. They read **tokens** \u2014 chunks of text that are roughly 3-4 characters each. The word \"hamburger\" might be 3 tokens. A period is 1 token. A space is sometimes its own token.\nWhen you use an LLM in an app, two things cost tokens:\n1. **Input tokens** \u2014 everything you send to the model (your instructions, conversation history, tool definitions)\n2. **Output tokens** \u2014 everything the model sends back (its responses, tool calls, etc.)\nBoth cost money and take time. **Output tokens are especially expensive** because the model has to generate them one at a time, and they can't be cached between requests.\nIn a Vercel AI SDK app, when you define tools for a model, you're telling it: \"Here are things you can do \u2014 call functions, fetch data, send emails.\" The model responds with something like:\n```json\n{\n  \"type\": \"tool_use\",\n  \"name\": \"getWeather\",\n  \"input\": {\n    \"location\": \"Austin\"\n  }\n}\n```\nThat works. But look at all the structural noise. Curly braces. Quotation marks. Commas. The word \"type\". The actual useful information is just: \"getWeather, location=Austin\". Everything else is JSON scaffolding.\n**Here's the question that drove this work:**\n> **How much of a model's output budget is spent on the envelope vs. the actual content?**\nThat question is worth sitting with. Every character the model spends on formatting is a character it can't spend on reasoning. Every closing brace is a fraction of a second added to your agent's response time. When your agent runs 10 tool calls in sequence, those fractions add up."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: What We Built"
        },
        {
          "role": "assistant",
          "content": "### What We Built\nWe built **ai-sdk-wire-middleware** \u2014 a middleware layer for the Vercel AI SDK v6 that replaces the verbose JSON tool-call format with a compact one-line format. Instead of that JSON block above, the model emits:\n```\n```\nThe middleware intercepts the model's output, parses those `<call>` tags, and converts them back into the real tool-call objects the SDK expects. To the rest of your code, nothing changed. streamText, generateText, onStepFinish, multi-step execution \u2014 everything works the same. Just fewer tokens, and more reliable multi-step chains.\nInstall it:\n```bash\nnpm install ai-sdk-wire-middleware\n```\nUse it:\n```typescript\nconst model = wrapLanguageModel({\n  model: anthropic('claude-sonnet-4-5'),\n  middleware: compactTools(),\n});\nconst result = await generateText({\n  model,\n  tools: {\n    getWeather: tool({\n      description: 'Get the weather for a city',\n      inputSchema: z.object({\n        location: z.string(),\n        units: z.enum(['metric', 'imperial']).optional(),\n      }),\n      execute: async ({ location, units }) =>\n        `72\u00b0${units === 'metric' ? 'C' : 'F'} in ${location}`,\n    }),\n  },\n  prompt: 'What is the weather in Austin in metric units?',\n});\n```\nOne line of middleware. The model emits `<call>getWeather location=\"Austin\" units=metric</call>` instead of the 6-line JSON block. The rest of your application never notices the difference."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: The Real Win: Multi-Step Agent Accuracy"
        },
        {
          "role": "assistant",
          "content": "### The Real Win: Multi-Step Agent Accuracy\nThe token savings are nice. But the headline result isn't about tokens \u2014 it's about **task completion**.\nWe built a multi-step agent benchmark \u2014 6 tasks requiring 3\u201312+ chained tool calls each \u2014 and ran it across 3 frontier open-weight models (GLM-5, GLM-5.1, GLM-5-Turbo) [\\[5\\]](#sources) [\\[6\\]](#sources). Each task requires the model to chain multiple calls toward a goal. Tasks like:\n* Fetch weather for 3 cities, then send a summary email\n* Search products, then calculate price with tax\n* Get the time in 4 timezones in parallel\n* Query active users from a database, then email a report\n| Mode        | Passes   | Pass Rate  | vs JSON       |\n| ----------- | -------- | ---------- | ------------- |\n| Native JSON | **1/18** | **5.6 %**  | \u2014             |\n| Compact     | **5/18** | **27.8 %** | **5\u00d7 better** |\nCompact completed the task **5\u00d7 more often** than native JSON.\n#### Per-Model Breakdown\n| Model       | JSON Passes | Compact Passes | Delta |\n| ----------- | ----------- | -------------- | ----- |\n| GLM-5-Turbo | 1/6         | 1/6            | Tie   |\n| GLM-5.1     | 0/6         | **2/6**        | +2    |\n| GLM-5       | 0/6         | **2/6**        | +2    |\nThe advantage is concentrated on the two GLM-5 models \u2014 the ones where JSON tool-calling most frequently breaks down. These are 744B-754B MoE models that rival GPT-5 and Claude Opus on coding benchmarks. The problem isn't their reasoning, it's the protocol.\n#### What Compact Does Better on Agent Tasks\n**Completes multi-step chains.** In the `search-then-fetch` task, JSON mode frequently loops on `searchProducts \u2192 searchProducts \u2192 searchProducts` without ever calling `calculate`. Compact mode completes the full `searchProducts \u2192 calculate \u2192 success` pipeline. The model sees the compact format, makes a call, gets a result, and moves to the next step \u2014 instead of getting stuck in a loop.\n**Attempts parallel calls.** In `time-around-world` (get time in 4 timezones), compact mode reliably emits all 4 `getTime` calls in parallel. JSON mode usually makes 1 call and tries to infer the other 3 from context. Parallel calls are critical for agent latency \u2014 a 4-step serial chain is 4\u00d7 slower than 1 parallel step.\n**Uses correct parameter names.** The compact signature shows field names explicitly (`query:string, maxResults?:int`), reducing the model's tendency to guess wrong names from verbose descriptions.\n**Self-corrects from errors.** Parse errors surface as inline `<tool-error>` tags that the model can respond to on the next step. The native JSON protocol produces a hard failure. The model sees its mistake and fixes it.\n> **Note:** Task success rate is low because tasks are hard \u2014 4\u201312+ expected calls per task, no retry logic, first-attempt only. A 6\u201328% pass rate is normal for this model class and difficulty. The delta between modes is what matters."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: How Much Do You Actually Save on Tokens?"
        },
        {
          "role": "assistant",
          "content": "### How Much Do You Actually Save on Tokens?\nWe ran two sets of benchmarks. One offline (deterministic, pure format cost) and one live (against real models, real APIs).\n#### What LLM Tokens Cost\nPricing varies wildly by provider and model tier. At the high end (GPT-5, Claude Opus) output runs \\~$10\u2013$25/1M. But there are far cheaper options:\n| Model                                      | Input (per 1M) | Output (per 1M) |\n| ------------------------------------------ | -------------- | --------------- |\n| DeepSeek V4-Flash                          | $0.14          | $0.28           |\n| DeepSeek V4-Pro [\\[7\\]](#sources)          | $1.74          | $3.48           |\n| Llama 3.1 8B (DeepInfra) [\\[8\\]](#sources) | $0.02          | $0.05           |\n| Claude Haiku 4.5 [\\[9\\]](#sources)         | $1.00          | $5.00           |\n| GLM-5 [\\[5\\]](#sources)                    | $1.00          | $3.20           |\n| GLM-5.1 [\\[6\\]](#sources)                  | $1.05          | $3.50           |\n| GPT-5.5 [\\[10\\]](#sources)                 | $5.00          | $30.00          |\n| Claude Opus 4.7 [\\[9\\]](#sources)          | $5.00          | $25.00          |\nOutput isn't always 5\u00d7 more expensive \u2014 DeepSeek V4-Flash is only 2\u00d7 (and costs pennies). On the high end, the ratio can be 4\u20136\u00d7. The takeaway isn't the ratio; it's that **every token you generate has real operational cost**: latency, throughput, and per-call spend compound across thousands of agent steps.\n#### Offline Benchmark\nWe measured a catalog of **13 tools** and **19 representative invocations** using a real BPE tokenizer (`o200k_base` via `js-tiktoken` \u2014 the same tokenizer GPT-4o uses).\n| Case                                     | Native JSON | Compact   | Reduction |\n| ---------------------------------------- | ----------- | --------- | --------- |\n| `getWeather(location)`                   | 25 t        | 11 t      | **56.0%** |\n| `getTime(timezone)`                      | 28 t        | 14 t      | **50.0%** |\n| `sendEmail(to, subject, body, priority)` | 46 t        | 30 t      | **34.8%** |\n| `searchProducts(query, max, inStock)`    | 37 t        | 21 t      | **43.2%** |\n| `bookMeeting(6 args, array)`             | 63 t        | 44 t      | **30.2%** |\n| `updateUserProfile(nested)`              | 67 t        | 50 t      | **25.4%** |\n| 19-case cumulative total                 | 762 t       | **474 t** | **37.8%** |\nSimple tools (1-2 parameters) save roughly **half** the tokens. More complex tools save 25-35%. The pattern is consistent: the more parameters a tool has, the less proportional savings \u2014 but you always save.\nAcross the full run:\n| Metric                 | Native JSON | Compact   | Reduction |\n| ---------------------- | ----------- | --------- | --------- |\n| Output tokens (total)  | 762         | 474       | **37.8%** |\n| Round-trip correctness | \u2014           | **19/19** | \u2014         |\nEvery single tool call parsed correctly back into the exact same structured arguments the native protocol would have produced.\n**37.8% is a format savings, not just a cost savings.** Those tokens translate to real operational improvements: lower per-call latency, fewer context-window slots wasted on formatting, higher throughput in production agent loops, and \u2014 on models with prompt caching \u2014 smaller cache entries and cheaper misses. Cost is the headline, but operational efficiency is the engine.\n**System-prompt overhead** also flips in your favor: with 13 tools the compact manual is **372 tokens smaller** than the equivalent JSON tool-def block (861 \u2192 490). With prompt caching this amortizes to \\~zero after the first turn.\n#### Live Benchmark (Real Models, Real API)\nOffline numbers are one thing. Real inference with real models tells a different story. We ran each case through `generateText` against **GLM-5, GLM-5.1, and GLM-5-Turbo** via the Z.AI provider \u2014 once with native JSON tool calling, once wrapped with `compactTools()`.\nConfiguration: temperature 0 (deterministic), one shot per case, no retries.\n| Metric              | Native JSON  | Compact     | Delta      |\n| ------------------- | ------------ | ----------- | ---------- |\n| Total output tokens | \\~803 avg    | \\~654 avg   | **\u221218.6%** |\n| Total input tokens  | \\~10,898 avg | \\~4,308 avg | **\u221260.5%** |\n| Strict match rate   | 8/10         | 9/10        | +1         |\n| Soft match rate     | 10/10        | 10/10       | \u2014          |\n| Mean latency        | \\~34.2 s     | \\~31.4 s    | \u2014          |\nThe big number here is **input tokens dropping 60%**. JSON schema for 13 tools clocks in at \\~861 tokens. The compact manual is \\~490 tokens. The model also has less structural noise in its own conversation history.\nThe output reduction (18.6%) is smaller than the offline projection (37.8%) for a simple reason: real models aren't perfect machines. They add extra spaces, quotes, and formatting the idealized compact string doesn't have. Models are trained on JSON, so they naturally drift toward JSON-ish verbosity even in the compact format.\nStill, 18.6% fewer output tokens and 60% fewer input tokens is meaningful. In a production agent loop running hundreds or thousands of tool calls per day, that's real cost and latency savings."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Ablation Studies"
        },
        {
          "role": "assistant",
          "content": "### Ablation Studies\nWe ran ablations to isolate the effect of each middleware component \u2014 removing the protocol manual, moving its position, or switching to JSON inside `<call>`. Each ablation ran 6 representative cases with 3 reps each on glm-5-turbo and glm-5.1.\n| Ablation          | Total Tokens | Equivalent | Delta vs Canonical | Effect                                                                 |\n| ----------------- | -----------: | :--------: | :----------------: | ---------------------------------------------------------------------- |\n| Canonical compact |         1083 |    16/19   |      baseline      | \u2014                                                                      |\n| no-manual         |         1231 |    18/18   |   **+148 tokens**  | Manual helps \u2014 instructs model to be concise                           |\n| placement=first   |         1184 |    18/18   |   **+101 tokens**  | End placement is better; core instructions first, formatting secondary |\n| syntax=json       |         1239 |    18/18   |   **+156 tokens**  | Wire format is more efficient than JSON even inside `<call>`           |\nKey finding: **the `<call>` wrapper alone saves some tokens, but the key-value wire syntax accounts for the majority of savings.** The protocol manual is a net positive \u2014 it tells models to be concise, which they otherwise aren't."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: How It Works"
        },
        {
          "role": "assistant",
          "content": "### How It Works\nThe Vercel AI SDK v6 has a feature called `LanguageModelV3Middleware` that lets you intercept and modify data at three points:\n```\n\u256d\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256e  transformParams       \u256d\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256e\n\u2502  generateText /   \u2502\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u25b6\u2502  - drop `tools`           \u2502\n\u2502  streamText       \u2502                        \u2502  - inject manual + sigs  \u2502\n\u2502  (your code)      \u2502                        \u2502  - rewrite history        \u2502\n\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256f                        \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256f\n         \u25b2                                                 \u25bc\n         \u2502                                       \u256d\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256e\n         \u2502  synthetic `tool-call` parts          \u2502  upstream model   \u2502\n         \u2502                                       \u2502  (text response)  \u2502\n         \u2502      wrapStream / wrapGenerate         \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256f\n         \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 parser \u25c0\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256f\n```\n1. **`transformParams`** \u2014 Before the request goes to the model. Strips out the JSON `tools` field and `toolChoice`. Each tool's JSON Schema is rendered as a one-line signature (`getWeather: location:string, units?:\"metric\"|\"imperial\"`) and appended to the system prompt. Previous tool-call history is rewritten into the same compact format so the model always sees consistent syntax. Tool result messages become user-role `<tool-result>` text blocks.\n2. **`wrapGenerate`** \u2014 After the model responds. Scans for `<call>...</call>` spans and converts them back into real tool-call content parts. Parse errors surface as inline `<tool-error>` for model self-correction.\n3. **`wrapStream`** \u2014 During streaming. A state machine watches for partial `<call>` and `</call>` tags that might be split across chunks, and reassembles them correctly. Handles 36 edge cases including partial attributes, split close tags, and nested text between calls.\n#### Wire Format\n```\n```\nFeatures:\n* **Key-value syntax**: `key=value` for flat records of primitives\n* **Arrays**: `attendees=[\"a\",\"b\"]` inline for list fields\n* **Nested flattening**: `profile.displayName=Alice` for one-level-deep objects\n* **Smart quoting**: bare words when safe (`location=Austin`), quoted when value has spaces\n* **JSON fallback**: tools with deeply nested schemas or unions use `{\"key\":\"val\"}` inside `<call>`\n#### Configuration\n```typescript\ncompactTools({\n  syntax: 'wire',            // 'wire' | 'json'   (default 'wire')\n  fallbackToJson: 'complex', // 'complex' | 'error' | 'force'\n  placement: 'last',         // 'first' | 'last'\n  manualHeader: undefined,   // override the manual injected into system prompt\n  debug: false,\n})\n```\n* `syntax: 'json'` uses `{\"key\":\"val\"}` inside `<call>` for tools that can't use wire format \u2014 saves some tokens vs native protocol but less than wire format\n* `fallbackToJson: 'error'` throws if a tool's schema is too complex for wire format; `'force'` tries to flatten everything (not recommended)\n* `placement: 'first'` puts the protocol manual at the start of the system prompt instead of the end (the ablation data shows end-placement is better)"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: This Isn't a New Idea"
        },
        {
          "role": "assistant",
          "content": "### This Isn't a New Idea\nMaking protocols more efficient is a well-established pattern:\n* **HTTP/2 HPACK** compresses HTTP headers by replacing repeated key-value pairs with a lookup table [\\[13\\]](#sources). Same concept: stop sending the same structural overhead over and over.\n* **Protocol Buffers** (Google's binary format) replaces named fields with numbered field IDs [\\[14\\]](#sources). The JSON tool protocol is basically the equivalent of sending XML for every API call \u2014 human-readable but wasteful.\n* **Prompt caching** (offered by Anthropic [\\[11\\]](#sources) and OpenAI [\\[12\\]](#sources)) reuses processed input tokens across requests. The compact format's smaller footprint compounds here \u2014 smaller cache entries, cheaper cache misses.\n* **Speculative decoding** generates multiple candidate tokens in parallel and keeps the first valid one. It reduces *latency* but doesn't reduce the number of tokens generated. The compact format reduces both.\nThe difference: all of the above optimize the *transport* \u2014 how data moves between systems. This middleware optimizes the *generation* \u2014 the model itself produces fewer tokens from the start."
        }
      ]
    }
  ],
  "dev": [
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Caveats"
        },
        {
          "role": "assistant",
          "content": "### Caveats\n**Model-dependent \u2014 not purely size-dependent.** The compact format is a system-prompt-only protocol. It strips the native `tools` field and relies on the model learning `<call>key=value</call>` from text. Some smaller models handle it well (Granite4.1:3b scores 10/19 compact with 35.6% token savings [\\[15\\]](#sources)), while larger models fail completely (Llama 3.1:8b scores 12/19 JSON but 0/19 compact [\\[16\\]](#sources)). On multi-step agent tasks Granite4.1:3b scores 0/6 in both modes \u2014 it can't chain calls regardless of format. **Tested strong on single calls**: GLM-5 (744B), GLM-5.1 (754B), GLM-5-Turbo (744B), Granite4.1:3b. **Tested weak on single calls**: Llama 3.1/3.2. Benchmark your specific model.\n**First-call quality dip on frontier models.** GPT-5 and Claude Sonnet 4.5 are heavily trained on the JSON tool protocol. They follow the compact format from a system prompt reliably, but expect a small accuracy hit on the very first call of a session before the format is in context.\n**Complex tool schemas lose savings.** Tools with nested objects, arrays, or union types can't use the wire syntax \u2014 they fall back to JSON inside `<call>`. If your entire toolset looks like `[{user: {name: string, address: {street, city, zip}}}]`, you'll barely save anything.\n**No structured output enforcement.** The middleware can't force the model to use a specific output schema (the Vercel middleware interface doesn't expose that). If you need guaranteed structured outputs, use the native JSON format for those specific calls.\n**Output tokens > input tokens on short sessions.** The system-prompt manual is \\~468 tokens (13 tools); the per-call savings are \\~10\u201320 tokens. With prompt caching the manual amortizes to \\~zero quickly. Without caching, you need \\~25 tool calls per session to break even."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: What Needs More Research"
        },
        {
          "role": "assistant",
          "content": "### What Needs More Research\nWe ran the agent benchmark, the ablations, and the cross-model sweep. The numbers are real and the pattern is clear \u2014 compact format helps. But this is one research pass across a handful of models and synthetic tasks. There's more to learn:\n* **Broader model sweep across provider tiers.** The agent accuracy win is measured on GLM-5-class models. Early results on Granite4.1:3b (10/19 single-call) and Llama 3.1:8b (0/19 compact) show that model architecture matters as much as size. Does compact format help on Claude Sonnet 4.5, GPT-5, and Gemini 2.5 Pro \u2014 or is the accuracy win specific to open-weight MoE architectures? A proper sweep across 20+ models would tell us.\n* **Harder, more realistic tasks.** Replace the synthetic task set with established benchmarks like Tau-bench or SWE-agent, where cumulative output-token cost and task completion rate are both measured end-to-end.\n* **Input-side compounding with prompt caching.** The one-time input savings from the smaller compact manual compound on providers with prompt caching (Anthropic, OpenAI), where the cache-miss cost is a one-time penalty. Real production data would make this concrete.\n* **Schema flattening for nested tools.** Dotted-key flattening (`address.city`, `address.zip`) and array-of-primitive encoding would extend savings to more real-world tool sets, where nested schemas are common.\n* **Why some models handle text-only protocols and others don't.** Granite4.1:3b handles single-call compact format (10/19) better than Llama 3.1:8b (0/19), but fails on agent tasks (0/6 across both modes). Understanding what makes a model follow a text-defined protocol vs. needing native API enforcement is worth investigating \u2014 it could guide both training improvements and protocol design."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Try It Yourself"
        },
        {
          "role": "assistant",
          "content": "### Try It Yourself\nAll benchmarks in this post \u2014 offline, live, ablation, and multi-step agent \u2014 come from the ai-sdk-wire-middleware repository. Every number you see here was generated by the code in that repo.\nTo reproduce the results:\n```bash\ngit clone https://github.com/thegreataxios/ai-sdk-wire-middleware\ncd ai-sdk-wire-middleware\nnpm install\n# Offline benchmark \u2014 deterministic, no API key needed\nbun run bench\n# Live benchmark \u2014 needs OPENROUTER_API_KEY or ZAI_API_KEY\nbun run bench:live\n```\nThe benchmark code is your starting point. Fork it, swap in your own tools and models, and compare numbers against your specific workload.\nBut you don't need to run benchmarks to benefit. Using the middleware is one line:\n```typescript\nconst model = wrapLanguageModel({\n  model: anthropic('claude-sonnet-4-5'),\n  middleware: compactTools(),\n});\n```\nThat's it. `streamText`, `generateText`, `onStepFinish`, multi-step \u2014 everything works the same way, just with fewer tokens and more reliable chains.\nIf you run benchmarks against your own toolset, I'd love to hear your numbers. DM me on X or open an issue on the repo.\n***\n1. ai-sdk-wire-middleware repository (benchmark code, ablation scripts). https://github.com/thegreataxios/ai-sdk-wire-middleware\n2. Vercel, \"AI SDK\" documentation. https://sdk.vercel.ai\n3. Vercel, \"LanguageModelV3Middleware\" reference. https://sdk.vercel.ai/providers/community/custom-providers/middleware\n4. OpenAI, \"tiktoken\" tokenizer library (o200k\\_base). https://github.com/openai/tiktoken\n5. Zhipu AI, \"GLM-5\" series model documentation. https://zhipu.ai\n6. Zhipu AI, \"GLM-5.1\" model card (754B MoE, 203K context, SWE-bench scores). https://openrouter.ai/z-ai/glm-5.1\n7. DeepSeek API pricing. https://api-docs.deepseek.com/quick\\_start/pricing\n8. DeepInfra pricing (Llama 3.1 8B). https://deepinfra.com/pricing\n9. Anthropic API pricing (Opus 4.7, Haiku 4.5). https://docs.anthropic.com/en/docs/about-claude/pricing\n10. OpenAI, \"Introducing GPT-5.5\" (pricing). https://openai.com/index/introducing-gpt-5-5/\n11. Anthropic, \"Prompt caching\" documentation. https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching\n12. OpenAI, \"Prompt caching\" guide. https://platform.openai.com/docs/guides/prompt-caching\n13. Ilya Grigorik, \"HPACK: The First Stable Version of the HTTP/2 Header Compression Standard\" (2015). https://blog.cloudflare.com/hpack-the-first-stable-version-of-the-http-2-header-compression-standard/\n14. Google, \"Protocol Buffers\" documentation. https://protobuf.dev\n15. IBM, \"Granite 4.1: 3b model card\" (model specs, benchmark scores). https://huggingface.co/ibm-granite/granite-4.1-3b\n16. Meta, \"Llama 3.1: 8B model card\". https://huggingface.co/meta-llama/Llama-3.1-8B"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: The Problem: PII Leaks Through Abstractions"
        },
        {
          "role": "assistant",
          "content": "### The Problem: PII Leaks Through Abstractions\nYour AI application uses the Vercel AI SDK. It's clean \u2014 `generateText`, `streamText`, a few lines of code, done. But every user message flows through your system intact:\n> \"I'm Alice Smith from Acme Corp. My email is `alice@example.com` and my phone is `555-0123`.\"\nThat string hits your:\n* **Logs** \u2014 Sentry, Datadog, whatever you're using\n* **Context windows** \u2014 passed to the LLM, stored in conversation history\n* **Tool calls** \u2014 maybe forwarded to a CRM or booking API\n* **Error traces** \u2014 when something breaks, the full message is in the stack\nOne misconfigured logger, one debug endpoint left open, one analytics pipeline you forgot about \u2014 and you've got a data breach waiting to happen.\nIn production AI systems, **PII isn't a compliance checkbox \u2014 it's a systemic vulnerability that travels through every abstraction layer.**"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: The Solution: Middleware That Redacts"
        },
        {
          "role": "assistant",
          "content": "### The Solution: Middleware That Redacts\nai-sdk-privacy-filter-middleware is a Vercel AI SDK [\\[1\\]](#sources) middleware that wraps any language model and automatically redacts PII from messages. It uses OpenAI's privacy-filter model [\\[2\\]](#sources) running locally via Transformers.js. [\\[3\\]](#sources)\nNo API calls. No cloud dependency. The 1.5B parameter model runs in your process \u2014 browser or Node.js.\n#### How It Works\n> **Model Architecture Note:** The privacy-filter model uses a sparse Mixture-of-Experts (MoE) architecture with 128 experts and top-4 routing per token. [\\[3\\]](#sources) While the full model is \\~1.5GB, only \\~50M parameters are active per forward pass \u2014 inference is fast once loaded.\nWrap your model with the middleware:\n```typescript\nconst openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });\nconst model = wrapLanguageModel({\n  model: openrouter('openrouter/free'),\n  middleware: privacyFilterMiddleware(),\n});\n```\nNow every `generateText` or `streamText` call automatically:\n1. **Detects** PII in user/system messages\n2. **Replaces** it with typed placeholders (`[PERSON_1]`, `[EMAIL_1]`)\n3. **Restores** original values in the LLM's response\n```\nUser sends:  \"I'm Alice, my email is alice@corp.com\"\nLLM sees:    \"I'm [PERSON_1], my email is [EMAIL_1]\"\nLLM replies: \"Hello [PERSON_1], I'll contact [EMAIL_1]\"\nUser sees:   \"Hello Alice, I'll contact alice@corp.com\"\n```\nThe LLM never sees the real PII. Your logs only contain placeholders. Compliance becomes architectural."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: What It Detects"
        },
        {
          "role": "assistant",
          "content": "### What It Detects\nThe model catches 8 categories of PII:\n| Type              | Placeholder   | Example                   |\n| ----------------- | ------------- | ------------------------- |\n| `private_person`  | `[PERSON_N]`  | Alice Smith               |\n| `private_email`   | `[EMAIL_N]`   | `` `alice@example.com` `` |\n| `private_phone`   | `[PHONE_N]`   | `+1-555-0123`             |\n| `private_address` | `[ADDRESS_N]` | 123 Main St               |\n| `private_date`    | `[DATE_N]`    | 1990-01-15                |\n| `private_url`     | `[URL_N]`     | `https://example.com`     |\n| `account_number`  | `[ACCOUNT_N]` | 1234-5678-9012            |\n| `secret`          | `[SECRET_N]`  | API keys, passwords       |"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: The Middleware Pattern"
        },
        {
          "role": "assistant",
          "content": "### The Middleware Pattern\nThe Vercel AI SDK's middleware system is the right abstraction for this. It sits between your code and the LLM \u2014 exactly where redaction belongs.\n```\nYour Code \u2500\u2500\u25ba transformParams (detect + redact PII)\n                        \u2502\n                        \u25bc\n               LLM sees redacted text\n                        \u2502\n                        \u25bc\n               LLM response (with placeholders)\n                        \u2502\n                        \u25bc\n          wrapGenerate/wrapStream (unredact placeholders)\n                        \u2502\n                        \u25bc\n               User sees original PII restored\n```\nThe middleware implements three hooks:\n* **`transformParams`** \u2014 redacts user and system messages before they reach the LLM\n* **`wrapGenerate`** \u2014 unredacts placeholders in non-streaming responses\n* **`wrapStream`** \u2014 unredacts placeholders in streaming responses via a transform stream\nOnly user and system messages are redacted. Assistant and tool messages pass through untouched \u2014 the LLM never outputs real PII, only placeholders that get restored."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Why Local Inference Matters"
        },
        {
          "role": "assistant",
          "content": "### Why Local Inference Matters\nYou could send messages to a cloud PII detection API. Many services offer this. But now you have:\n* **Network latency** \u2014 every request adds 100-500ms\n* **Data residency issues** \u2014 user data leaves your infrastructure\n* **Rate limits and costs** \u2014 per-request pricing adds up fast\n* **Availability dependency** \u2014 their downtime is your downtime\nRunning the model locally via Transformers.js eliminates all of this. The model loads once (\\~1.5GB), then inference runs in milliseconds on CPU (WASM) or GPU (WebGPU).\n#### Runtime Support\n| Runtime | Device | Status               |\n| ------- | ------ | -------------------- |\n| Node.js | WASM   | Supported            |\n| Browser | WebGPU | Supported            |\n| Browser | WASM   | Supported (fallback) |\nAuto-detects the best available device. WebGPU when available, WASM fallback otherwise.\n> **Warning:** WebGPU does not work in Safari. Use WASM fallback or deploy server-side for Safari users."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Configuration"
        },
        {
          "role": "assistant",
          "content": "### Configuration\n```typescript\nconst openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });\nconst model = wrapLanguageModel({\n  model: openrouter('openrouter/free'),\n  middleware: privacyFilterMiddleware({\n    // Only redact specific entity types (default: all)\n    entityTypes: ['private_person', 'private_email', 'private_phone'],\n    // Minimum confidence score (default: 0.8)\n    minScore: 0.9,\n    // Whether to unredact LLM responses (default: true)\n    redactResponses: true,\n    // Custom placeholder format\n    placeholderFormat: (type, n) => `<<${type}_${n}>>`,\n    // Device override ('wasm' | 'webgpu')\n    device: 'webgpu',\n    // Model loading progress callback\n    onProgress: ({ status, progress }) => {\n      console.log(status, progress);\n    },\n  }),\n});\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Eager Initialization"
        },
        {
          "role": "assistant",
          "content": "### Eager Initialization\nThe model loads lazily on first use. First request will be slower (\\~5-15s depending on hardware) while the model downloads and initializes. To pre-load:\n```typescript\nconst openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });\nconst middleware = await createPrivacyFilter({ device: 'webgpu' });\nconst model = wrapLanguageModel({\n  model: openrouter('openrouter/free'),\n  middleware,\n});\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Multi-Provider Support"
        },
        {
          "role": "assistant",
          "content": "### Multi-Provider Support\nWorks with any AI SDK provider:\n```typescript\n// OpenRouter (default example)\nconst openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });\n// OpenAI\n// Anthropic, Gemini, Cohere, etc.\n// Any provider that returns the standard AI SDK interface\n```\nThe middleware is provider-agnostic \u2014 it operates on messages, not model implementations."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts.\n\nCover this topic: Browser vs Server: Where to Run It"
        },
        {
          "role": "assistant",
          "content": "### Browser vs Server: Where to Run It\nThe middleware works in both environments, but the trade-offs differ.\n> **Architecture Note:** The privacy-filter model is a sparse Mixture-of-Experts (MoE) with 128 experts. [\\[2\\]](#sources) Only \\~50M parameters activate per token, making inference lightweight despite the \\~1.5GB download size.\n| Environment | Device                    | Model Size                          | Best For                                                  |\n| ----------- | ------------------------- | ----------------------------------- | --------------------------------------------------------- |\n| **Browser** | WebGPU (or WASM fallback) | Downloaded per user                 | Client-side apps, data never leaves the device            |\n| **Server**  | WASM                      | Loaded once, shared across requests | API routes, guaranteed availability, no per-user download |\n> **Warning:** WebGPU is not supported in Safari. Use WASM fallback or server-side deployment for Safari users.\n#### Browser (WebGPU)\nRunning in the browser means:\n* **Zero server cost** \u2014 model inference happens on the user's GPU\n* **Maximum privacy** \u2014 PII never leaves the device, not even to your server\n* **Per-user download** \u2014 every user downloads \\~1.5GB on first use\n* **Hardware variance** \u2014 WebGPU support varies; WASM fallback is slower\nIdeal for: Chat UIs, client-only apps, compliance requirements that demand on-device processing.\n#### Server (Node.js + WASM)\nRunning on the server means:\n* **Predictable performance** \u2014 consistent hardware, no WebGPU variability\n* **No per-user overhead** \u2014 model loads once, serves all requests\n* **Standard deployment** \u2014 works on any Node.js host (Vercel, Railway, etc.)\n* **Slightly slower inference** \u2014 WASM vs WebGPU, but still milliseconds\nIdeal for: API routes, serverless functions, applications where you control the infrastructure.\nBoth work. Browser for privacy guarantees; server for operational consistency."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Get Started"
        },
        {
          "role": "assistant",
          "content": "### Get Started\n**Repository:** github.com/TheGreatAxios/ai-sdk-privacy-filter-middleware\n**Install:**\n```bash\nnpm install ai-sdk-privacy-filter-middleware\n```\n**Quick start:**\n```typescript\nconst openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });\nconst model = wrapLanguageModel({\n  model: openrouter('openrouter/free'),\n  middleware: privacyFilterMiddleware(),\n});\nconst result = await generateText({\n  model,\n  prompt: \"My name is Alice Smith and my email is alice@example.com\",\n});\n// PII is redacted before reaching the LLM\n// Response placeholders are restored before you see them\nconsole.log(result.text);\n```"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Validating Redaction with Debug Logging"
        },
        {
          "role": "assistant",
          "content": "### Validating Redaction with Debug Logging\nTo verify the middleware is working correctly, use the debug callbacks to inspect what's happening at each stage:\n```typescript\nconst openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });\nconst model = wrapLanguageModel({\n  model: openrouter('openrouter/free'),\n  middleware: privacyFilterMiddleware({\n    entityTypes: ['private_person', 'private_email'],\n    minScore: 0.8,\n    redactResponses: true,\n    placeholderFormat: (type, n) => `<<${type}_${n}>>`,\n    onRedact: ({ original, redacted, entities }) => {\n      console.log('[onRedact] original:', original);\n      console.log('[onRedact] redacted:', redacted);\n      console.log('[onRedact] entities:', JSON.stringify(entities, null, 2));\n    },\n    onUnredact: ({ raw, unredacted }) => {\n      console.log('[onUnredact] raw:', raw.slice(0, 200));\n      console.log('[onUnredact] unredacted:', unredacted.slice(0, 200));\n    },\n  }),\n});\nconst result = await generateText({\n  model,\n  prompt: \"My name is Alice Smith and my email is alice@example.com\",\n});\nconsole.log('=== FINAL OUTPUT ===');\nconsole.log(result.text);\n```\n**Example output:**\n```\n[onRedact] original: My name is Alice Smith and my email is alice@example.com\n[onRedact] redacted: My name is <<PERSON_1>> and my email is <<EMAIL_1>>\n[onRedact] entities: [\n  {\n    \"entity_group\": \"private_person\",\n    \"score\": 0.9999969899654388,\n    \"word\": \" Alice Smith\"\n  },\n  {\n    \"entity_group\": \"private_email\",\n    \"score\": 0.9995789726575216,\n    \"word\": \" alice@example.com\"\n  }\n]\n[onUnredact] raw: Hello <<PERSON_1>>, I've noted your email <<EMAIL_1>>\n[onUnredact] unredacted: Hello Alice Smith, I've noted your email alice@example.com\n=== FINAL OUTPUT ===\nHello Alice Smith, I've noted your email alice@example.com\n```\nThis confirms the LLM only saw placeholders, never the real PII. The `onRedact` callback shows exactly what entities were detected and their confidence scores, while `onUnredact` demonstrates the placeholder-to-original mapping being restored."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: When to Use This"
        },
        {
          "role": "assistant",
          "content": "### When to Use This\n**Use browser deployment when:**\n* You're building a client-side chat interface\n* PII must never reach your server (maximum privacy)\n* Users have modern browsers with WebGPU support\n* You can tolerate the per-user model download\n**Use server deployment when:**\n* You're building API routes or serverless functions\n* You need predictable, consistent performance\n* You want to avoid pushing 1.5GB to every user\n* You're already running Node.js infrastructure\n**Don't use this when:**\n* You need centralized redaction across multiple languages \u2014 use privacy-python-server instead\n* You can't afford 1.5GB memory per instance (browser or server)\n***\n1. Vercel, \"AI SDK\" documentation. https://ai-sdk.dev\n2. OpenRouter, \"OpenRouter AI SDK Provider\" documentation. https://openrouter.ai/docs\n3. OpenAI, \"privacy-filter\" model card, HuggingFace. https://huggingface.co/openai/privacy-filter\n4. HuggingFace, \"Transformers.js\" documentation. https://huggingface.co/docs/transformers.js"
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a deep-dive technical blog post section covering emerging infrastructure for AI agents. Use @mentions as signposts."
        },
        {
          "role": "assistant",
          "content": "x402 is Coinbase's open protocol for internet-native payments that enables seamless blockchain transactions using ERC-3009 USDC. This article explores how to extend x402 to any blockchain through EIP-3009 forwarding contracts, with a focus on SKALE Network's zero-gas infrastructure that enables instant, cost-free transactions across any token on EVM-compatible chains.\nx402 is an open protocol for internet native payments created at Coinbase. Coinbase has been deeply aligned with Circle, and chose to build x402 process around the the use of ERC-3009 native USDC.\nWith an increasing number of blockchains being created, many of which are utilizing bridged assets instead of official deployments from stablecoin issuers, this article explores ERC-3009, forwarding payments with ERC-3009 Forwarder, implementing with minimal facilitator changes, and more.\nWhile enables x402 on any blockchain, a major unlock of this initiative was to bring x402 to SKALE, the only network of infinite block space with zero gas fees and instant finality."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog post section about blockchain and AI crossover topics. Tight paragraphs, punchy tone, real examples.\n\nCover this topic: Technology Overview"
        },
        {
          "role": "assistant",
          "content": "### Technology Overview\nThe following section provides an introduction to x402, blockchains, SKALE Network, stablecoins and tokenization, ERC-3009, and the ERC-3009 Forwarder. If you are already familiar with these topics and want to skip to the implementation, click here.\n#### x402\nx402 by Coinbase is an open protocol for internet native payments. This allows for access to be given to resources in a new manner; without the need for traditional login/registration, OAuth, or complex registration. It also bakes monetization directly into the flow for resource access.\nSpecifically, x402 is blockchain agnostic and runs at the speed of blockchain. The faster the blockchain, the faster your payment. While designed for digital dollars, the standard is technically agnostic to allow for any token to be used as payment.\nAdditionally, it was built with a number of key use cases in mind such as agentic payments to allow for real time API access to resources, micro transactions for access and creation of content, and more broadly a native integration into any web based service allowing for monetization to occur without a middleman.\n#### SKALE\nSKALE is a network of blockchains capable of bringing an infinite amount of block space to the world in the form of SKALE Chains. SKALE Chains are EVM compatible blockchains that are run by the pool of SKALE validator nodes. With a unique economic model that allows communities, developers, businesses, enterprises, and governments to purchase their own blockchains for  a flat fee, the underlying SKALE Chain can be configured and utilized in whatever way they see fit, including zero gas fee transactions.\nWith the instant finality, large block size, and zero gas fee nature of a SKALE Chain; it's an ideal fit to bring zero cost operations to x402 for every token; a far greater opportunity for developers and stablecoin issuers compared to using subsidized USDC on certain chains.\n#### Stablecoins\nIf you are unfamiliar with stablecoins, they are a cryptocurrency designed to remain at a stable value in relation to some other asset. The largest stablecoins today are Tether USD (USDT) and Circle USD (USDC) which are tokens issued by their respective companies intended to stay pegged at the value of $1 USD per token.\nThe usage of stablecoins within x402 makes a lot of sense for many of the core use cases called out such as for cloud compute and storage providers. Stablecoins with zero gas fees is an even stronger pull to providers who don't have to weigh the cost of gas into their services.\n#### ERC-3009 & Forwarding Contract\nERC-3009 allows the transfer of fungible assets through signed authorization. Through the use of meta-transactions, signatures are used to approve the movement of assets. This brings with it many unique benefits which are explored in the official EIP-3009.\nThe unique part about 3009, is that it's actually implemented within a few stablecoins, such as USDC and EURC by Circle, but very few others. While this limits blockchains and tokens without ERC-3009 native tokens, it does not stop us from moving forward.\nWhile there are a number of ways to implement the meta-transactions, for to start I chose to go with a **Forwarding** contract for ERC-3009 since that is what the majority of facilitators are currently offering. My belief is that when a technology is new we can always explore more complex and fine-tuned designs, however, the easier it is to integrate into existing tooling the faster we can bring the usage over to SKALE and everyone can benefit from the zero gas fees.\n> The current forwarding contract is not audited. This contract is offered without any guarantees or warranties under the MIT License. See the full license here."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write a blog section for DevRel about AI agents and blockchain infrastructure. Opinionated, technical but accessible. Use numbered format like 'No. 1 | Topic'.\n\nCover this topic: Implementation"
        },
        {
          "role": "assistant",
          "content": "### Implementation\nThe following section explores all the code written and steps taken to achieve a working implementation.\n#### Forwarding Payments with ERC-3009\nThe entire setup of facilitators currently relies on ERC-3009 compatible tokens, i.e USDC.\nTherefore, to ensure that we could utilize as much of the existing facilitator as possible we needed to implement a `Forwarding` contract. While slightly more inefficient, the gas costs are irrelevant on a chain like SKALE and the extra approval is a price worth paying to achieve my goal (I can iron it out later).\nI created the EIP-3009 Forwarder which uses the core structure of the core proposal, but through a forwarding contract. *The difference?* The sender who is signing the authorization must first approve the token being spent via authorization.\nAs mentioned above, I think this is an acceptable tradeoff. This specific forwarding contract is designed to support a single token only. This was again done to mimic the setup and flows of a traditional facilitator.\n#### x402 Example Scripts\nOnce the forwarding contract was built with a small test suite, it made sense to ensure this worked directly. I then setup a `Bun` mono-repo here which has a config folder and an ethers-v6 example.\nMake note of the first key step within the script below, which is the approval checks and approve as needed functionality.\n```typescript\n// ===================\n// STEP A: User approves ERC-20 (with smart allowance check)\n// ===================\nconsole.log(\"Step A: Checking and setting allowance\");\nconst approveAmount = ethers.parseUnits(\"1\", token.decimals); // 1 token\nconst currentAllowance = await erc20Contract.allowance(userAddress, FORWARDER_ADDRESS);\nconst minimumRequired = (approveAmount * 20n) / 100n; // 20% of approve amount\nconsole.log(`Current allowance: ${ethers.formatUnits(currentAllowance, token.decimals)}`);\nconsole.log(`Minimum required (20%): ${ethers.formatUnits(minimumRequired, token.decimals)}`);\nif (currentAllowance < minimumRequired) {\n\tconsole.log(\"Insufficient allowance, approving...\");\n\tconst approveTx = await erc20Contract.approve(FORWARDER_ADDRESS, approveAmount);\n\tawait approveTx.wait();\n\tconsole.log(`\u2713 Approved! Tx: ${approveTx.hash}`);\n} else {\n\tconsole.log(\"\u2713 Sufficient allowance exists, skipping approval\");\n}\n```\nThis code ensures some amount is approved to the forwarder in advance which can then be used for micro-transactions.\n> I think in these cases it's an acceptable flow for agents as they can do a single approval for small batches i.e $10 of $0.01 gets you 1000 transactions.\nYou can deploy the forwarding contract and play with these scripts directly. The example script working to execute a USDC (without ERC-3009) payment on SKALE Europa Testnet can be seen here:\n```shell\nStep A: Checking and setting allowance\nCurrent allowance: 999999999999.78\nMinimum required (20%): 0.2\n\u2713 Sufficient allowance exists, skipping approval\nUser balance: 49.78 USDC\nStep B: User signs authorization for 0.01 token transfer\nNonce: 0x94c1a3e2f911070928b2d1cee1c31736decabe7ac044b020f4b808806b58eb8b\nValid from: 2025-10-04T05:34:14.000Z\nValid until: 2025-10-04T06:34:14.000Z\nNonce already used: false\nDomain separator: 0x056b9108f4b1e6aca877b44e3afa782d7a46328ecb25ee6d4eb037c02cfeaaa0\nDomain: {\n  name: \"USDC Forwarder\",\n  version: \"1\",\n  chainId: 1444673419,\n  verifyingContract: \"0x7779B0d1766e6305E5f8081E3C0CDF58FcA24330\",\n}\nAuthorization value: {\n  from: \"0xdEAC50014a531969d76D9236d209912F4B1AacDB\",\n  to: \"0xD1A64e20e93E088979631061CACa74E08B3c0f55\",\n  value: \"0.01 (10000)\",\n  validAfter: 1759556054,\n  validBefore: 1759559654,\n  nonce: \"0x94c1a3e2f911070928b2d1cee1c31736decabe7ac044b020f4b808806b58eb8b\",\n}\n\u2713 User signed authorization: 0xa8e092aea8b4b0001d...\nSignature components: v=28, r=0xa8e092aea8b4b0001dd9e1f72c718855e0ff0b91668dd9d92ba3df474b051370, s=0x3f1380d002c243e432f2292aaed3bac5cb64b1f4a494e128d6e3fa33e722cfa7\nStep C: Relayer executes the transfer (pays gas)\nFinal allowance check: 999999999999.78\n\u2713 Transfer executed! Tx: 0x6e0da427fa6976cbc3100f155c77113fc2508249fcb042763baeb3af264370da\n\u2713 Gas paid by relayer: 92297 units\n\u2713 0.01 tokens transferred from 0xdEAC50014a531969d76D9236d209912F4B1AacDB to 0xD1A64e20e93E088979631061CACa74E08B3c0f55\n\ud83c\udf89 Gasless transfer complete!\n- User paid 0 gas for the transfer\n- Relayer paid the gas fees\n- Transfer executed via signed authorization\n```\n#### Minimal Facilitator Modifications\nThe facilitator is an optional service within the x402 flow that simplifies the process of verifying and settling payments. While optional, it can help accelerate the adoption and addition of x402 into applications that don't have the experience or the resources to build the necessary functionality.\nThe two key functions that a facilitator offers are:\n1. Verification of payment payloads submitted by clients (buyers).\n2. Settling of payments on the blockchain on behalf of the servers\nThis enables any web server to utilize the blockchain to handle payments and settlement without the need of direct connection to the blockchain within their existing servers.\nThe majority of facilitators (and x402 payments) have been focused on Base so far. While Coinbase/Base may be subsidizing all gas fees for USDC transactions making x402 cheap, there are no guarantees that lasts forever OR benefits toward non-USDC stablecoins and tokens.\nWith the core protocol being built around the usage of USDC to start, the facilitators are utilizing an Ethereum Improvement Proposal (EIP) labeled EIP-3009 which allows transfer with authorization; further extending EIP-712 signatures and meta-transactions directly within the token contract.\nHowever, as not all blockchains are able to attain a native deployment by Circle and with many existing stablecoins like USDT not being natively EIP-3009 compatible, I set out to ensure that that facilitators could work with any token with minimal modifications.\nThe proposed changes include using an `EIP-3009 Forwarder` smart contract in Solidity which wallets can approve to spend tokens on their behalf. With such a design, it allows any token on any blockchain to be utilized with almost no changes to an EVM facilitator as the current flows remain almost identical.\nTo prove this, I made a pull request to Faremeter by Corbits to add support to their facilitator. The majority of changes come from additional configuration as you can see in the following:\n```typescript\ntype NetworkInfo = {\n\taddress: Address;\n\tcontractName: string;\n\t/* Added Below */\n\tforwarder?: Address;\n\tforwarderName?: string;\n\tforwarderVersion?: string;\n};\n```\nThe most complicated changes were needed within the actual EVM facilitator code, of which the original changes were actually pretty light. They simply had to allow the facilitator to defer to a forwarder when present else fallback to the actual ERC-20 with ERC-3009 support.\nI wound up refactoring the whole file to better re-use code, but an example here:\n```typescript\nasync function createContractConfig(\n  useForwarder: boolean,\n  chainId: number,\n  forwarderVersion: string | undefined,\n  forwarderName: string | undefined,\n  forwarderAddress: `0x${string}` | undefined,\n  publicClient: PublicClient,\n  asset: `0x${string}`,\n  contractName: string,\n): Promise<ContractConfig> {\n  const address = getContractAddress(useForwarder, forwarderAddress, asset);\n  const domain = useForwarder\n    ? generateForwarderDomain(chainId, {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        version: forwarderVersion!,\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        name: forwarderName!,\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        verifyingContract: forwarderAddress!,\n      })\n    : await generateDomain(publicClient, chainId, asset);\n  // Validate contract name for non-forwarder cases\n  if (!useForwarder && domain.name !== contractName) {\n    throw new Error(\n      `On chain contract name (${domain.name}) doesn't match configured asset name (${contractName})`,\n    );\n  }\n  return { address, domain };\n}\n```\nfrom here showcases the dynamic use of `useForwarder`.\nWhen the facilitator is called, it uses the incoming configuration of token and chain to validate if the forwarder is needed. After which the core facilitation stays 1:1 as the actual EIP-712 signature validation and then meta-transaction execution remains identical.\n#### Why x402 on SKALE\n> This section is opinionated.\n**\"Why SKALE?\"** is a question that I have been getting asked for over 4.5 years now (as of 10/1/2025). I think as a developer you find your preferred tech stacks and for everyone it's a bit different. SKALE however really is unique. The combination of performance, stability, innovation, and feature set is unmatched across the Web3 space.\nIn the case of x402 -- there is quite literally no network better suited to dominate. I've been asking developers building what they value most with x402. The answer is always one of two things:\n1. The cheapest costs possible (i.e gas fees) which allows facilitators to reduce their opex and not have to pass it onto buyers as service fees\n2. Speed. Speed. Speed. They want the chain to be fast and they are prioritizing real finality when possible (i.e Solana > Base).\nIf you were unaware:\n1. SKALE Chains have zero gas fees\n> This doesn't mean that SKALE doesn't make money. SKALE Chains are pre-paid monthly by application and chain owners. No different than many of the most successful cloud models in the world like Amazon Web Services or Google Cloud\n2. Instant Finality\n> Once a transaction is posted, the block and transactions cannot be reversed. The fork-less nature of a SKALE Chain means that current chains which operate around 1-2s block times are faster most L1s and retain better finality with lower risk. Additionally, smaller SKALE Chains with co-located nodes (think Hyperliquid style) could reduce this down to potentially a fraction of the time with instant finality.\nAdditionally, the last thing is scalability. While some blockchains today may have the capacity for handling a few thousand transactions per second or peaks of higher; the whole world will never run on a single blockchain (for many reasons).\nSKALE also makes it possible to run an infinite amount of blockchains for x402, payments, stablecoins, and the broader onchain finance landscape as it continues to grow."
        }
      ]
    },
    {
      "messages": [
        {
          "role": "user",
          "content": "Write an opinionated weekly roundup section about trends in the agentic economy for developers.\n\nCover this topic: Conclusion"
        },
        {
          "role": "assistant",
          "content": "### Conclusion\nI think x402 is one of many recent protocols that is incredibly exciting for the future of the machine economy. I previously wrote The Rise of the Machine Economy which outlined my thoughts about how agentic payments will grow.\nAs onchain payments are still in their infancy, the growth potential here is massive. While Turing-complete blockchains enable programmable payments; the natural integration within the broader internet makes x402 a potential catalyst to bring many businesses onchain.\nWith this potential growth, the only network that is capable of scaling to handle an infinite amount of payments (of any size, including sub-cent) is SKALE. Based on this, I think that a SKALE Chain (of variable sizing) will become a default part for businesses looking to access x402.\n***"
        }
      ]
    }
  ]
}