26+ years building software. AI-native engineer. Building production systems with coding agents. Shipping open source. Sharing what works and what breaks.
🟩🟧⬜⬜⬜⬜⬜⬜⬜⬜ - $100k MRR
Joined January 2023
- Tweets1.6K
- Following217
- Followers112
- Likes1.3K
your agent passed the eval. would you trust it in production?
that’s where Waza gets interesting.
Microsoft's open-source tool helps you test AI agents against defined tasks and catch regressions before users do.
start simple:
1. pick a real task.
2. define what success looks like.
3. run the eval.
4. fix failures and rerun.
the real test is whether your agent still works after the next change.
github.com/microsoft/waza
what's missing from your current eval setup?
Left a few agents running over the weekend.
Told myself I'd kill them later.
Came back to a $68 bill for machines that just sat there.
Same model, same prompt, just time.
The quiet cost hits harder than the loud ones.
Anyone else leave them on by accident?
MoneyByOnline.com is for sale at $2,900.
Clear name if you’re building anything around making money online.
domains.atom.com/lpd/name/mo…
I asked my laptop if a simple BTC moving average strategy would have made money last year. It ran the backtest, showed the drawdown, and gave me the numbers.
Vibe-Trading turns plain English into market research, backtests, and multi-agent analysis. One install, then it works with Claude Code. 37k stars on GitHub.
github.com/HKUDS/Vibe-Tradin…
What strategy would you test first?
This paper looks at what actually works in multi-agent systems, based on 28k real workflows.
Shared memory beat debate. Clear ownership of context beat free-form handoffs.
Makes sense when you see the results. Yet many agent frameworks still get this wrong.
Worth reading if you're building with multiple agents.
Paper: arxiv.org/pdf/2610.31709
Google open-sourced a way to catch bad specs before an agent starts coding.
Elephant-Goldfish splits the job in two. The elephant reads the history, architecture, and constraints, then drafts the spec. The goldfish starts fresh and challenges it from different angles.
You make the final call. The agents do the drafting and checking.
I like this because coding agents often start writing code before the plan is clear. This forces the spec to stand on its own first.
Works with Claude Code, Codex, and others. Apache 2.0. It's a set of guidelines, not a product.
github.com/google/elephant-g…
Microsoft just open-sourced a harness that runs up to 1,024 coding agents with no boss.
No lead agent. No one telling the others what to do.
Every worker does the same simple loop.
Look around.
Claim a piece of the work.
Build it.
Check it.
Merge it.
They talk through a shared git repo, a chat channel, and a findings board. That is the whole coordination layer.
On the five hardest ProgramBench tasks, one agent passed about 19% of the tests. 128 agents got that to about 29%. On pandoc, 1,024 agents hit 55%, up from 34%. With a stronger model, 32 agents reached about 80%.
The interesting part is not the big number.
Going from 1 agent to 8 only added about 1.4 points.
And they did not say what it cost in tokens.
More agents can help. They do not help for free, and they do not help much until you add a lot of them.
I still want the same three things from any of these setups.
What ran.
What it cost.
What a person still had to approve.
A thousand agents with no receipt is just a bigger bill.
Repo is MIT. Worth a look if you care about how these things actually coordinate.
Paper: arxiv.org/abs/2609.26781
Project: aka.ms/Agensh
draft a x long post:
github.com/microsoft/Agensh
Heavier harnesses are burning 2–3x the tokens.
Same model. Same task. No better score.
I have watched this. The loop gets fat. The bill gets fat. The diff looks the same.
A cheaper model does not fix a setup with no brake.
What ran. What it cost. What a person still had to approve.
If you cannot show those three, it is a demo.
Most web frameworks add a layer. This one tries not to.
Plod is a REST framework for Goose. Actix-style routes, scopes, extractors, middleware. OpenAPI in, types and a router out.
The line I like: “takes its time, not yours.”
No function table. Routes are code. Middleware compiles into the handler. Workers share nothing.
Early. Names will move. Still the cleanest Goose HTTP thing I have seen.
github.com/kaitk/plod
💰 YOUR NEXT ONLINE BRAND COULD START HERE
🚀 Domain for Sale: MoneyByOnline.com
Every online business starts with an idea. The right domain gives that idea a name people can remember.
MoneyByOnline.com is a brandable domain for entrepreneurs ready to build in the online income space.
Imagine using it for:
✅ An online money-making platform
✅ An affiliate marketing business
✅ A side-hustle or passive-income blog
✅ Digital products, courses, or business resources
Instead of starting with a complicated name, build around a domain that communicates your niche right away.
🎯 Have a plan to build an online business? This domain could be the right fit.
👉 View the listing and make your offer today:
domains.atom.com/lpd/name/mo…
Serious buyers only. If it fits your vision, take the next step and make it yours.
I used to blame the model.
Then I looked at the bill.
Same prompt sent again because the prefix cache missed. Same tool call retried because nothing told the agent to stop.
The model was fine. The loop was not.
Coding agents can write code. But can they reason about space and prove their answers with evidence?
S-Agent 2.0 takes a different approach. It turns coding agents into spatial reasoning agents, using evidence to ground their answers instead of relying on the model's guess.
The interesting part is the benchmark result. The paper reports that S-Agent 2.0 outperforms GPT-6 Astra on MMSI-Bench and ReVSI-Bench.
For agent builders, this raises a useful question. How much of an agent's ability comes from the model itself, and how much comes from the system built around it?
A general model may know a lot, but spatial tasks need more than knowledge. The agent needs to reason about relationships and support its conclusions with evidence.
That is what makes this worth a read. Specialized agents may get better results by changing how they work, not only by using a bigger model.
Paper: arxiv.org/abs/2610.28354
Project: ropedia.github.io/S-Agent-2.…
Better models wont fix a bad agent system.
You still need to control what gets cached, how much it can spend, which tools it can call, and what needs human approval.
A cheap model can still run up a big bill or do something it shouldnt.
Show me what the agent did, what it cost, and where a human had to step in. Thats what I want to see before trusting it in production.
AI agents dont need more freedom. They need less guessing.
Google's Rust style guide got me thinking. Clear rules mean fewer random decisions about how code should look.
Otherwise, you end up fixing the same inconsistencies in every PR.
I had rather spend 5 mins defining conventions than keep correcting the same stuff.
What rules do you give your coding agents?
google.github.io/styleguide/…
The model gets the attention. The harness gets the software shipped.
After 26+ years building software, I have learned that completing tasks isn’t the same as delivering a working product.
Five agents can finish five tasks and still ship nothing if integration, verification, and ownership fail.
Smarter models raise the ceiling. Better harnesses make delivery repeatable.
The real benchmark is not what your agents can do. Its what your system can reliably ship.
TypeScript's type checker is getting a Rust rewrite.
tsrs aims to replace the TypeScript 7 compiler and language server, with the same conformance target and lower memory use.
Its already available on npm, so you can test it against real projects today.
The hard part isn't making it faster. Its matching TypeScript's behavior closely enough that teams can switch without breaking their workflows.
That’s the benchmark I'd watch.
github.com/oxc-project/tsrs
A small specialist just took over the memory harness.
Hy-Memory-30B-A3B is trained to decide what to remember, how to write it, and when to update existing memories. It replaces the general LLM in systems like Mem0 and MemOS.
On fixed benchmarks, it reportedly beats Claude Opus and DeepSeek Flash at memory writing.
The interesting part is what moved inside the model. Logic we treated as permanent harness code became a specialized model task.
As models absorb more of that work, the harness will need to focus on what still requires hard guarantees: budgets, permissions, verification, and recovery.
The boundary between model and harness keeps moving.
huggingface.co/tencent/Hy-Me…
The best voice agent isn't the one that speaks fastest. It's the one that never leaves you wondering if it's still there.
Google's ADK guide tackles a real UX problem: silence breaks trust.
The tradeoff is latency vs. natural conversation. Keeping users informed matters as much as getting the answer right.
Great engineering, @GoogleAI.
developers.googleblog.com/st…
