Starting this account from zero.
I build AI agents, automations & products — and I’m going to share the process in public.
Expect:
→ builds & experiments
→ useful AI workflows
→ what works and what fails
→ progress from an idea to a real product
No polished highlight reel. Just building.
Let’s see where this goes.
THE SAME AI AGENT WENT FROM 25/49 TO 49/49 TASKS WITHOUT CHANGING THE MODEL.
They changed the interface.
DOM control → 25/49, 5.4s/task, rank #12
WebMCP → 49/49, 3.2s/task, rank #1
Same agent. Same model.
The interface was the upgrade.
@AnthropicAI The 30%+ speedup is nice, but the cost reduction might matter even more for agents.
Faster + cheaper loops make always-on agent workflows much more practical.
Claude Sonnet 5.5 just dropped.
30%+ faster.
Up to 30% lower cost for most work.
And a clear upgrade over Sonnet 5.
The interesting part isn't just the benchmark bump.
Faster models + cheaper agent loops means the economics of running always-on Al agents keep getting better.
This matters more than another leaderboard win.
NVIDIA just launched its Open Agent Safety Platform with 100+ organizations.
The interesting part isn’t another safety framework.
It moves enforcement outside the agent itself.
OpenShell → sandbox + policies
Sentry → out-of-band hardware watchdog
If an agent moves outside its boundaries, Sentry can quarantine it in milliseconds.
That’s a pretty important architectural shift.
Instead of asking the model to behave:
→ isolate it
→ scope file/network/tool access
→ audit actions
→ enforce limits outside the agent
More autonomy inside harder external boundaries.
This is exactly what I want to test next:
same agent, same task
prompt-only guardrails
approval gates + scoped tools
runtime/sandbox controls
Then compare failures, latency and completion rate.
@JensenHuang@spacexai The biggest shift here is enforcement outside the model. Prompt-level guardrails can fail. Sandboxes, scoped permissions and out-of-band monitoring give agents boundaries they can’t simply reason around.
Computer-use agents may not need to “look” at the screen nearly as much.
Agent Desktop reads the actual accessibility tree instead of relying on screenshots.
The repo reports 78–96% fewer tokens on dense apps.
But the bigger part is reliability:
→ structured UI state
→ stable element refs
→ stale-target detection
→ safer retries
→ machine-readable JSON
That feels like a much better primitive for desktop agents than repeatedly asking a vision model where to click.
Next I want to benchmark this against screenshot-based computer use on the exact same tasks.
@GithubProjects Reading the accessibility tree instead of pixels feels like the right abstraction for computer-use agents.
Stable refs + structured state should make retries and verification way more reliable than guessing coordinates from screenshots.
@GithubProjects BYOK is a nice choice here. Database tools are exactly where I’d rather control the model/provider instead of having AI locked into the product.
@vercel_dev 1M context + tool use with lower token usage is a pretty interesting combination for agents. Cost per completed task matters a lot more to me than raw token price.
@GithubProjects “Self-improving” is the part I’d want to measure carefully. The interesting question isn’t whether the agent can modify itself — it’s whether those changes consistently improve results without creating regressions.
@GithubProjects Four Mac Minis running a 70B model as one cluster is wild. Local inference gets much more interesting once spare machines can become one shared compute pool.
@n8n_io This is a pretty big shift for n8n. The agent becomes reusable infrastructure instead of something trapped inside one workflow. Really curious how far this goes with shared memory, evals and approval gates.
@DanKornas Login flows are exactly where full autonomy usually breaks down.
Keeping the agent running while handing only the sensitive step to a human feels like a much better pattern than stopping the whole workflow.