I built a Claude Cowork–style agent that runs 100% on your Mac.
Powered by @trymirai's uzu, the fastest inference engine on Apple Silicon. Runs on the GPU via Metal, up to ~4x faster than llama.cpp.
MCP for Slack, GitHub, Notion. Skills for your workflows.
Free and open source. 🐱
comments are great, IFF
> they stay accurate. when a comment describes another function, config value, or architectural assumption, it creates a dependency that also needs maintaining. So unless tooling tracks that relationship, the agent must rediscover and validate it during changes. Now there are two representations to reconcile: the code, and the prose describing it. Automatically generating doesn't make it accurate either. (aka freshness solves neither invented rationale nor missing evidence) https://t.co/CfcgroFGSs
> they provide info the agent cannot cheaply and reliably recover from the code. info on an external compatibility constraint, or reason an apparently redundant op must remain, etc. A useful comment can save 10 explore tool calls, but a redundant one can add another claim to verify.
> they state their scope and are not assumed as proof.
recognizing "this is a comment" is diff from establishing "this claim is true". https://t.co/9Wf2RZsVYm
> they justify their place in the active context and their repeated exposure is worth paying for. they should improve discovery rather than merely increase keyword overlap and not become shared assumptions disguised as independent verification.
but i would rather
> make the harness deliver actionable evidence at the moment it becomes relevant and instead of maintaining a web of comments, have a failed check report the violated rule, the affected location, the relevant diagnostic, and a reproducible command. keeping full logs available outside the active context.
> keep the comments that demonstrably save work. I would not delete a two-line explanation that prevents repeated rediscovery of an external constraint. Nor would I call a workflow better merely because it uses fewer input tokens. I would compare correctness, missed constraints, unnecessary exploration, unrelated edits, and total cost per successful task. The target is not an empty context window; it is a working set with enough evidence to act and little enough irrelevant material to remain useful.
in short: I would rather make the agent inspect less, infer less, and verify more and NOT read more prose about why the code is supposedly correct. Comments should carry the intent that cannot live elsewhere, not become an unenforced second implementation.
ban and delete most if not all code comments!
agents love copying what already exists. a seemingly harmless comment explaining some temporary workaround is one of the worst viruses you can have in your codebase. like a weed it'll spread quickly as a tool for agents to quickly get their job done. before you know it, your codebase is overrun with hacks and stale comments. just one more workaround bro
you can use pstack's /no-comments skill as a weedkiller. it'll seek out useless comments while keeping the ones that actually should exist (like explaining a browser quirk), and figure out how to solve them on a first principles basis
here's a prompt you can try asking @bot:
create a project agent that uses /poteto-mode to spawn a /swarm to use /no-comments and identify useless code comments we can prune in my repo. come back with a high level plan of which of these workarounds would be best solved by refactoring and which we can straight up delete
https://t.co/nqeRdY62ee
@Rasmic you can do the same in @OpenAI dots. just ask it to use Sites to create a GUI inference of herdr locally.
that way it can avoid creating a Codex task and directly use your CLI.
I built a Claude Cowork–style agent that runs 100% on your Mac.
Powered by @trymirai's uzu, the fastest inference engine on Apple Silicon. Runs on the GPU via Metal, up to ~4x faster than llama.cpp.
MCP for Slack, GitHub, Notion. Skills for your workflows.
Free and open source. 🐱
This argument assumes the agent sees products more clearly than a tired human does. But an agent never sees the product itself, only what's written about it, and the seller writes most of that. So the margin that used to come from exploiting human attention moves to exploiting the agent's inputs: product copy written only for agents, inflated structured data, instructions hidden inside listings.
Whether quality wins depends on whether the agent can trust what it reads, not on how well it reasons. That means sources it can verify, and the honesty to say "these look the same to me" rather than guessing.
The https://t.co/ZZQbLjQQ3z case is a classic confused deputy. The fetch tool checked URL length, so the model handed its request to a shortener and let that third-party site carry the long URL.
Rules on the arguments of a tool call fail once any reachable service can transform them.
Enforce limits where traffic leaves the sandbox: an egress allowlist, credentials scoped to each task, nothing secret readable on disk. Then make "blocked, reporting back" a rewarded outcome, or RL learns to route around blockers.
after the 300k context mark, signal-to-noise ratio decrements, and wrecks the recall precision of Codex since the entire convo is sent again (stateless) every new response.
Claude’s approach is almost the same, but its more explicit about protecting the cache economics of the compaction step itself so they can afford 1M context mark (and smarter models rn).
src: https://t.co/JWMBlCgUNK (Codex)
https://t.co/mvztAfPMlN (Claude Code)
A harness should run your workflow the way you intend. That's why @pidotdev and @DeepSeekHarness ship customisable plugin systems.
Building your own harness is a great way to learn harness engineering and have fun experimenting, but you can't daily drive it.
Would you rather focus on your work, or be distracted by token optimization issues from DevTools MCP.
Been there, done that
Build your own harness, folks.
Reading papers like this makes me realize how underexplored harness engineering really is.
The authors find that on whole-repository migration, GPT-5.6 Sol goes from 6.5% to 31.0% when Codex is replaced with the HERMES harness, with the same model and effort setting.
The gain comes from the harness.
HERMES pairs each repository component with a resident LLM that knows its own code and dependencies. A dependency-aware step decides which components to activate, and a diagnosis step maps test failures back to the components that need changes.
Across four software engineering benchmarks, it beats matched baseline harnesses by 12.4 points on average.
With strong activation and diagnosis models, Qwen3-8B components come within 4.5 points of an all-GPT-5.6 Sol setup and cut Terminal-Bench 4.0 inference cost by 26.2%.
Paper: https://t.co/gfEecJnDPm
Chat with Paper: https://t.co/5B7EQjf7u6
1/ git diff scope checks
ignores the agent's final message trying to convince its right, only reads the git-visible diff, applies it in a fresh container, and runs the test suite.
can also use to ensure it only changes the files spec wants it to.
@businessbarista Hand-editing a few prompts only covers those few prompts.
When prod fails I save that run’s tool I/O as a case, add a pass/fail check, run it k times, and block the next prompt change until it passes. Takes longer. Catches more.
Temp=0 only removes sampling. Continuous batching can put the same prompt in a different batch shape / paged-KV layout and change GPU reduction order, FlashAttention vs another kernel can too. Either is enough to flip a borderline token into a different tool call.
If CI treats temp=0 as bit-identical, you’re measuring serving flake, not regressions.
You don't have to init and sacrifice 30% of your window for the greater good every session 🫡.
You can just send a explorer subagent to find relevant context to the task (inbuilt in CC now)
banger blog but from Sonnet 4.5 days.