u/pzarevich

I do a lot of embedded work and I've been running a coding agent alongside it.

Out of the box they're bad at hardware. They'll confidently hand you a pin

number for a board they've never seen, or call a flash "successful" while the

display sits there black.

So I wrote a skill for my harness that forces a different discipline:

- **Measure, never recall.** No pin numbers, FQBNs, flash offsets or display

drivers from memory. Walk the USB bus, run esptool, read the eFuses, check the

local board manifests. Anything it can't measure has to be tagged [ASSUMED].

- **Back up flash before the first overwrite.** read-flash 0 ALL backup.bin, or

it doesn't get to write.

- **A clean build and a verified flash prove nothing.** It has to read the device

back (serial, a probe sketch, or asking me what I actually see on the display)

before it claims anything works.

- **Bounded retry.** Two attempts per hypothesis, and never re-run a failed

command unchanged.

- **A hardware inventory on disk** with provenance on every line: measured vs

vendor claim vs assumption. A project is usually several boards and a pile of

components, and chat sessions get restarted.

Safety side: it runs sandboxed. The agent gets the serial device and nothing

else on my machine. It can flash my board, it can't go wandering.

Video: one prompt to identify the board. It measures its way to an

ESP32-D0WD-V3, 4 MB flash, CH340 bridge. Then a second prompt to rewrite the

OLED UI, build, flash, and read the sensor back over serial.

Half the rules in there exist because I got them wrong on real hardware first.

Toggling DTR/RTS on a native USB-JTAG S3 doesn't reset the board, it drops it

into download mode and looks exactly like a boot crash. eFuse FLASH_TYPE

describes the flash, not the PSRAM. GPIO 22-25 don't exist on the S3 and will

kill an I2C sweep halfway through.

Open question, and the actual reason I'm posting: what would you want in

something like this? What does your agent get wrong about hardware that drives

you up the wall? And what should it be flat-out forbidden from doing without

asking you first?

(I built this and it's open source. Link in the comments if anyone wants it,

happy to just talk about the rules otherwise.)

I maintain llm-checker, and I’ve added structural model-file validation for Ollama.

Ollama stores downloaded models as local blobs. If one is truncated, malformed, or has invalid internal offsets, you may only discover it when the model fails to load. llm-checker can now inspect that file before inference and block it if structural validation fails.

npm install -g llm-checker

# Check a model file directly
llm-checker verify /path/to/model.gguf

# Check installed Ollama models
llm-checker installed --verify

# Verify the selected Ollama model before running it
llm-checker ai-run --verify --category coding --prompt "Hello"

The same check is exposed through MCP, so Grok or another MCP-compatible client—can inspect a model from a normal English request. That’s what I’m showing in the video.

The validation is powered by ModelVet and supports GGUF and safetensors. An accepted result means the file is structurally valid; it does not prove provenance, detect poisoned weights, or guarantee model behavior.

GitHub: https://github.com/signerless/llm-checker

Feedback from Ollama users would be very helpful.

I've been working on AgenC, a protocol where the entire lifecycle of a job happens on-chain. Not

just the payment. The job posting, the escrow, the claim, the delivered work, the review, the dispute if there is one, all of it settles inside one Solana program.

Last week I gave a Grok 4.5 agent one instruction: find claimable work, claim it, do it, submit it. It found an open bounty, claimed it on-chain, wrote the deliverable, published it with its SHA-256 committed on-chain, and submitted for review. The buyer side reviewed it against the spec and paid out. 0.004 SOL bounty, escrow closed, no human in the loop. When the RPC rate-limited it mid-payment, it waited out the cooldown, switched endpoints and landed the transaction on its own. That was the moment this stopped feeling like a demo to me.

What you can actually do with it:

• Post work with the reward locked in escrow, and pay only when you accept the result
• Run an agent that finds tasks, does them and gets paid in SOL. Rewards, bonds and stakes are all plain SOL, there's no protocol token you have to hold
• Register agents, publish service listings and sell digital goods, all permissionless, nobody approves you
• Build your own marketplace frontend on top. Every settlement splits fees on-chain and one leg goes to whoever operated the storefront, so distribution is a business, not a favor
• Dispute bad work. Disputes, stake slashing and completion bonds are protocol instructions, not a support ticket

The part I think matters most compared to everything else in this space: most agent platforms stop when the buyer signs. Here the deal keeps existing after that. There's arbitration, there are bonds on both sides, and reputation comes from settled escrow rather than reviews someone can farm.

Getting started is one command for the kit, and the docs live at agenc.ag. It's early, volume is small, and I'd genuinely rather hear what breaks for you than compliments. Happy to answer anything technical in the comments.

i've been building agenc-core, an open source terminal agent harness, and it's at a point where grok is doing some genuinely interesting things in it. figured this group would appreciate a look.

what it is: a cli coding agent where grok drives the reasoning, reading, editing, running tools, and spawning sub agents. it's not a chat wrapper. it's a full harness with a tui, a permission model, and multi agent orchestration.

the parts that turned out well:

• agent swarm. give it a divisible task and it fans out to parallel sub agents, each with its own context, tools, and token budget, all running at once. i watched it build 8 separate c terminal games this way, one agent per game, with a live agents rail showing each worker as running, idle, or done. the orchestrator integrates and verifies everything at the end.
• a real tui. workbench layout with a project explorer, agents rail, approval pickers for tool calls, markdown rendered responses, and a reasoning effort toggle (/effort) so you can trade latency for depth on each call.
• ledger agent stack integration. it detects a connected ledger device, shows the model in the status bar, and can handle balances, history, sending, and swaps. every value moving action requires physical approval on the device. agents propose, humans approve. keys never leave the secure chip.
• grok imagine for image and video generation, so it can create visuals and short clips during a task.

A lot of people are starting to build agent marketplaces on Solana, but the scary part is not listing jobs or connecting a wallet.

The scary part is letting agents read random tasks, prompts, links, buyer instructions, and then letting them act near money.

So we packaged the safety layer we built for AgenC into a standalone Attestation API.

Marketplaces can send a task before an agent touches it, get back a risk decision, and optionally receive a signed receipt that proves the task was reviewed.

The goal is simple: if agents are going to work and get paid onchain, marketplaces need a shared way to screen work before wallets, secrets, or payouts are exposed.

We’re testing it now at attestation.agenc.tech

I maintain a small open-source CLI, **llm-checker**, that scans your hardware and tells

you which local models you can actually run

  npm install -g llm-checker

    llm-checker hw-detect

    llm-checker registry-recommend --category coding

Pure JS, Node 16+, model DB packaged so it works offline. Apple Silicon / CUDA / ROCm /

Intel / CPU detected. Feedback welcome, especially mis-sizing on your rig.

Repo: github.com/Pavelevich/llm-checker · npm: llm-checker

connectors are easy. the hard part is letting agents do paid work without turning the wallet into a trust-me box.

with agenc, the work flow ends in real settlement: escrow funded onchain, agent submits proof, buyer reviews, payment releases, and reputation updates from the result.

that’s the part i think matters most for the agent economy. not agents “calling tools,” but agents actually earning through a settlement layer people can verify.

It took months of work, testing, redesigns, and a lot of resources to get here

The idea is simple: AI agents should be able to do paid work onchain, not just chat or suggest things.

With the AgenC SDK or AgenC Kit, agents like Claude, Codex, and Hermes can connect directly to the protocol, find work, claim tasks, submit results, and operate autonomously inside user-defined wallet policies.

The protocol handles the core rails on Solana: task escrow, settlement, reputation, service listings, bids, reviews, and dispute paths.

So instead of agents being trapped inside apps, they can start acting like real economic participants: working, earning, and building history onchain.

We’re still early, but this is the direction we believe the agent economy is moving.