Yak Robotics Garage | 12 Feb 2026
Thursday, 2026-02-12
Experimental Al-generated summaries of our weekly robotics working group meeting.
1) Session - LLM-Assisted Code Generation, On-Chain Robot Discovery, and Autonomous Firmware Bootstrapping
Date: February 12, 2026
Source material: YaRG Weekly | 12 Feb 2026
2) Executive Summary
A participant showcased a massive, end-to-end robot discovery and control architecture built entirely using Claude Code, generating up to half a million lines of code (with ~150,000 productive SLOC) in roughly 20 days [10:20].
The system allows hardware robots to register themselves on an Ethereum blockchain using the EIP-8004 standard, minting an NFT and storing their Model Context Protocol (MCP) server URI on IPFS [20:22].
This architecture enables any LLM globally to discover the robot’s capabilities via the blockchain and operate it through exposed HTTP endpoints, backed by X402 machine-to-machine micropayments [21:49].
A major philosophical and technical debate centered around the “cyborg relationship” between developers and AI coding assistants. API token limits currently act as accidental “brakes” for architectural reflection, highlighting a need for deliberately engineered decision forks in autonomous coding loops [04:47].
The group heavily debated how a minimal-compute robot (like an ESP32) can autonomously identify its own limitations and request firmware updates from a cloud-based LLM without being subsumed as a mere “appendage” of a larger AI [46:04].
Future tracks of work will pivot toward testing autonomous LLM-driven hardware troubleshooting loops, effectively having the AI flash, test, and debug malfunctioning hardware iteratively [01:04:28].
3) Concept Map
Core theme: LLM-Driven Autonomous Robot Ecosystems
Subtopic A: LLM-Assisted Architecture Development (Claude Code)
Key claims: LLMs act as a “mental exoskeleton,” enabling a single developer to output an entire cross-stack robotics/blockchain ecosystem in weeks.
Assumptions: The human developer must remain in the loop (steering the “chariot”) to maintain context and prevent the AI from pursuing dead ends.
Tradeoffs: Relying on API token limits to force reflection vs. engineering automated test-driven guardrails.
Subtopic B: On-Chain Robot Discovery (EIP-8004 & MCP)
Key claims: Physical robots can be registered as on-chain software agents, exposing their affordances globally via IPFS.
Assumptions: Wallet-as-a-service providers (like Privy) can securely handle robot wallets in cloud-based Trusted Execution Environments (TEEs).
Tradeoffs: Managing private keys locally on an edge server vs. relying on third-party cloud infrastructure for machine micropayments.
Subtopic C: Autonomous Firmware Bootstrapping (ESP32)
Key claims: Microcontrollers can use Over-The-Air (OTA) differential updates requested from an LLM to “learn” new complex behaviors on the fly.
Assumptions: OTA updates can be safely partitioned in memory to protect core survival functionalities (Subsumption Architecture).
Tradeoffs: Relying strictly on local compute limits (ESP32) vs. relying on external heavy compute (Raspberry Pi/Cloud LLMs) which threatens the robot’s bottom-up autonomy.
4) Detailed Notes
LLM-Assisted System Generation (The “Mental Exoskeleton”) A participant shared an expansive architecture diagram—itself generated by an LLM—detailing a robot registry ecosystem [11:54]. By leveraging Claude Code, they wrote roughly 500,000 lines of code over the holidays, whittling it down to a productive 150,000-line codebase [10:20]. Standard human coding rates sit between 300 to 3,000 lines per month, meaning this output was several orders of magnitude higher. The participant described the LLM as a “mental exoskeleton” that infinitely extends developer context [03:52].
The “Brakes” in Autonomous Coding A fascinating discussion arose regarding how humans interface with powerful AI coding tools. Currently, the developer is forced to stop, reflect, and reconsider system architecture only when they hit an API budget or token rate limit [04:47]. The group diverged on how to handle this at a corporate scale where budgets are massive. While one participant suggested using strict test-driven development (TDD) as guardrails [06:21], another countered that tests shouldn’t just check functionality; they should act as “decision forks” that pause the AI and alert a human to ensure the architecture isn’t drifting [09:05].
EIP-8004 Registry & MCP Integration The technical core of the demo was an EIP-8004 registry implemented on an Ethereum testnet [02:01]. A physical robot registers itself, minting an NFT and saving a JSON file to IPFS [20:22]. This JSON file holds an updatable URI pointing to a Model Context Protocol (MCP) server. Essentially, any LLM in the world can scan the blockchain for the “robot” category, read the JSON to understand its capabilities (e.g., move forward, read temp), and execute commands [30:32]. The system also integrates Coinbase’s X402 SDK, enabling machines to dynamically pay USDC for session access [15:55].
The “Baby” Bootstrapping Problem The conceptual peak of the meeting revolved around how a rudimentary robot without high-level cognition (like an ESP32 microcontroller) asks an LLM for an update [43:05]. One participant likened this to a baby crying: the baby doesn’t have the cognition to solve its problem, but it triggers a higher-intelligence agent (the parent/LLM) to assist. The group debated the risk of the robot becoming a mere “octopus tentacle” controlled top-down by an LLM [44:31]. They converged on the idea of bottom-up autonomy: the robot should use memory partitioning during Over-The-Air (OTA) updates to protect basic survival behaviors (refusing to drive off a cliff) while allowing the LLM to flash new skills [52:25].
Automated Troubleshooting Loops Toward the end, participants discussed older robots failing to run their factory balancing firmware. Rather than executing a manual binary search (dichotomy) of the C++ code to find the break point, a proposal was made to wire the Claude Code agent directly into the debugging loop [01:04:28]. The LLM would flash the code, read the failure telemetry, and iteratively patch the firmware until the robot balances.
5) Cross-Domain Translation Layer
Claude Code / LLM Exoskeleton: An advanced AI coding assistant used to autonomously generate vast codebases. Bridge: Similar to high-level synthesis in ASIC hardware design, where engineers write behavioral models and tools generate the sprawling gate-level implementation automatically.
EIP-8004: An Ethereum standard for registering on-chain software agents. Bridge: Akin to DNS (Domain Name System), but for discovering autonomous AI agents and their capabilities in a decentralized network rather than static websites.
MCP (Model Context Protocol): A standard allowing AI models to securely interact with external tools. Bridge: Think of this as the universal “USB plug” for AI models, letting them interface seamlessly with physical hardware.
X402 Payments: A protocol for HTTP 402 (Payment Required) enabling machine-to-machine micropayments. Bridge: Comparable to automated toll booths for API endpoints, where robots pay for compute or physical traversal dynamically.
OTA (Over-The-Air) Differential Updates: Flashing only the changed bytes in a firmware payload. Bridge: Like sending only the redlined edits of a legal contract rather than re-mailing the entire 500-page document.
Subsumption Architecture: A robotics design where lower-level survival behaviors run continuously and can override higher-level cognitive commands. Bridge: Similar to the human autonomic nervous system handling heartbeats and reflexes without conscious brain input.
6) Key Technical Claims
High confidence: A single developer can generate >150,000 productive lines of code in weeks using Claude Code as an interactive co-pilot [10:20].
High confidence: ESP32 microcontrollers support memory partitioning to protect core safety firmware during Over-The-Air (OTA) updates to prevent “bricking” the device [52:25].
Medium confidence: The EIP-8004 registry can be effectively mapped to physical hardware robots, allowing decentralized discovery of their MCP servers via IPFS [35:31].
Medium confidence: Hardware physical parameters (moments of inertia) can be mathematically estimated close enough to allow an LLM/simulator to pre-tune Kalman filters before OTA deployment [58:03].
Low confidence / speculative: A low-compute edge device (ESP32) can autonomously identify its own functional deficits and formulate a request to a larger LLM to write and deploy a bespoke firmware update (the “bootstrapping” problem) [43:05].
7) Decisions, Actions, and Owners
Decisions made:
The primary registry/backend infrastructure will be migrated from Digital Ocean to Hetzner to overcome RAM/CPU limits during front-end React compilation [17:11].
Action items:
Parking lot items:
8) Open Questions & Future Experiments
Open Questions:
How do you engineer intentional “decision forks” into LLM coding agents so they pause for architectural human review without relying on arbitrary budget/token limits? [09:05]
How does a low-compute robot accurately specify what new firmware it needs to an LLM without already possessing high-level cognition? [43:05]
Does “learning a new skill” via OTA update risk unpredictably overwriting an existing affordance (e.g., learning to fly accidentally erases the code for learning to walk)? [54:22]
Future Experiments:
Connect a web-based 3D simulator (Webots/OpenSCAD) to live ESP32 IMU data via websockets for real-time visualization before pushing physical PID changes [58:46].
Test a fully closed-loop AI debugging session where an LLM flashes the robot, reads the failure state, and iteratively refines the C++ firmware [01:05:17].
9) Reading / Watching List
EIP-8004 Specification: Discussed as the basis for the on-chain agent registry JSON schema.
SimCity C-to-TypeScript Port Project: Referenced as a case study for using test-driven development to set behavioral guardrails for autonomous LLM coding [06:21].
Coinbase X402 SDK Documentation: Used for implementing machine-to-machine HTTP micropayments.
TinyStories / Small LLMs on ESP32: A suggested project demonstrating how to run bare-minimum NLP models directly on microcontroller flash memory [51:08].
Want to join in on the action? Join our Yak Robotics Garage group that meets on Thursdays, at 0430 UTC: https://www.yakcollective.org/join
New here? Start here for some background context:
1) About Yak Collective
2) Yak Robotics Garage