DEV Community: TerminalBlog

Codex Just Made GPT-6 Astra Its Default — and Nobody Is Talking About It

TerminalBlog — Thu, 10 Sep 2026 04:34:57 +0000

While everyone was watching Claude Code's release train, OpenAI's Codex quietly shipped seven stable releases in three weeks — 0.148 on August 18 all the way to 0.154.0 on September 9. No hype, no launch event, just a changelog that keeps getting longer.

And buried in that wave are three things that genuinely change how Codex feels to use: GPT-6 Astra is now the bundled default model, experimental worktrees finally landed, and Windows users get a real background daemon. Here's what each one means if you're not a release-notes reader.

1. GPT-6 Astra is the default now

The last time we covered Codex (0.147, portable plugins and auto-approvals), the model story was GPT-5.6. A month later, the model picker and the Amazon Bedrock catalogs list GPT-6 Astra, and starting in 0.153.4 it is the bundled default when you haven't pinned a model (0.153.4 release notes).

For beginners, "default model" is the single most important line in any agent changelog: it is what runs when you just type codex and start working. Two things to know about Astra's tiers:

The Fast tier is described in-app as "2x speed, increased usage" — OpenAI actually corrected the label from 1.5x to 2x in 0.153.2, which tells you how quickly they're iterating on it.
It is also available through Amazon Bedrock, so teams already on AWS can route Codex through their existing account instead of a ChatGPT login (0.154.0, 0.153.3).

The same wave that made Goose the most model-agnostic agent in open source (Goose v1.47–v1.50) is landing inside Codex: newest frontier model, first-class, as the default.

2. Experimental worktrees: dangerous experiments without the danger

The headline feature of 0.154.0 is experimental worktree support. If you haven't run into worktrees: they let you create isolated checkouts of your repository — separate folders where the agent can go wild without touching your working copy.

Codex's version (#42652, #43069, #43120, #43286) works like this:

codex exec --worktree or /worktree inside a session creates an isolated checkout for new or forked sessions
You can browse and resume those worktrees later from the TUI
The whole thing lives behind a feature flag, so nothing changes until you opt in

Why this matters for beginners: the scariest thing about letting an agent refactor your code is "what if it breaks my working tree mid-task?" With worktrees, the agent experiments in a side copy, and you review the diff before anything touches your real branch. This is the same direction Claude Code (worktree sandbox escapes have been a real attack story) and Qwen Code have been pushing — isolation is the pattern.

3. Windows finally gets a first-class background server

Codex 0.154.0 gives Windows sessions a shared background Codex server, with daemon lifecycle commands and managed updates (#42405, #42392). If you've ever had a terminal agent die because you closed the window it started in, this is the fix: sessions now survive in a background process you can reconnect to.

It's part of a month-long Windows hardening push, which is worth calling out for anyone on the platform:

Windows Store PowerShell sandbox execution fixed in 0.152.0
Sandbox fixes for Unicode user paths in 0.150.0 (the classic C:\Users\اسم problem) and Microsoft Store PowerShell in 0.152.0
Native sandbox provisioning and a private-desktop command runner in the 0.154.0 line

Windows has long been the stepchild of terminal agents — the tooling assumed macOS and Linux. That's changing, version by version.

4. The agents dashboard: multi-task workflows became usable

0.149.0 and 0.150.0 turned Codex into something closer to a task manager than a single-session REPL:

codex agents — an interactive dashboard to search, start, open, rename, and stop tasks (0.149.0)
codex queue — send messages to existing local or remote sessions, so a running task can be steered from outside
@mentions of other Codex tasks — reference another task by name and ask agents to read, create, or message it (0.150.0)
/cd, /pwd, /cwd — manage the working directory mid-session instead of restarting

The practical picture: spawn one long-running task, codex queue it a follow-up, and @-reference its output from a second task. That's the multi-agent pattern without a separate orchestration tool.

5. Vim mode grew up

Codex's Vim mode picked up a surprising amount of polish across the wave:

/ and ? search with n/N navigation (0.152.0)
u undo and Ctrl+R redo, preserving complete drafts including pasted content (0.153.0)
. to repeat your last edit (0.150.0)
R replace mode with dot-repeat and better Escape handling in legacy terminals (0.154.0)

If you live in a terminal, this turns the composer from "a text box that happens to be in Vim" into an editor that behaves the way your muscle memory expects.

6. Safety got quieter and stricter

The security-relevant changes are easy to miss because they don't make headlines — but they're the reason to actually update:

Untrusted projects no longer supply project-level AGENTS.md instructions (0.150.0) — the prompt-injection vector of "clone a repo, open it, get hijacked" took a direct hit
Startup avoids running workspace-controlled helpers before trust is established, and the macOS sandbox blocks terminal input injection (0.154.0)
Sandbox restrictions fail closed for denied or unreadable paths on Linux and Windows (0.148.0)
Deny-read rules survive permission changes, and managed policy stays enforced
Credential redaction improved in app-server diagnostics (0.150.0) — provider, auth-refresh, and attestation fields are scrubbed
Guardian review history now survives compaction, restarts, and forks (0.152.0–0.153.0), and stale approvals are rejected after new user instructions

That last cluster matters: Guardian is Codex's approval-review system, and "history survives compaction" means the agent can't quietly forget an earlier approval or denial when the conversation gets summarized. For anyone running Codex unattended, this is the difference between a guardrail and decoration.

7. Plugins became manageable, MCP got polished

The plugin story, which started with 0.146/0.147, matured:

codex plugins CLI can list, install, and remove plugins from remote marketplaces (0.153.0) — no more hand-editing config to try a plugin
Existing sessions pick up newly installed plugin tools and refresh skills after upgrades (0.154.0)
MCP connections coordinate OAuth token refreshes and surface login challenges instead of silently replaying rejected calls (0.154.0)
Extensions can inspect or replace MCP tool results before they reach the model (0.151.0) — a debugging superpower
Individual MCP tools support an output_token_limit (0.152.0) so one chatty server can't blow your context

What to actually do

Update: codex update — or if you're on the desktop app, let the managed updater run.
Check your model: run /model and confirm you're on GPT-6 Astra; if you're on a Max/Pro plan, the Fast tier is the "2x speed" option.
Try worktrees for your next scary refactor: codex exec --worktree and let it experiment in an isolated checkout.
Windows users: update and look for the daemon lifecycle commands — background sessions that survive window closes.
Re-check automation safety: if you run Codex unattended, the AGENTS.md trust change and Guardian compaction fixes in 0.150–0.153 are worth an upgrade alone.

What the wave says

Three weeks, seven releases, no launch event. OpenAI is treating Codex like infrastructure now — shipping model support, isolation primitives, and trust fixes in small, boring increments. That's actually the most reliable kind of progress for a tool you build on: the interesting features (Astra, worktrees) get attention, but the safety fixes are what make it safe to leave running.

If you've been comparing agents on marketing instead of release notes, this is the wave that should update your mental model of Codex.

Full changelog: rust-v0.148.0...rust-v0.154.0

Disclosure: some links on this site are affiliate links (aiFiesta).

OpenHands Just Added the Git Sync Button Everyone Begged For — And Made Kimi K3 Free by Default

TerminalBlog — Thu, 10 Sep 2026 04:34:19 +0000

OpenHands 1.14 landed five hours ago. Most point releases are forgettable — version bumps, dependency updates, a bug fix or two. This one isn't.

The headline feature is a Git Sync page inside the Automations tab. One click. Push. Pull. Branch switching. No terminal context-switch. No git status → git add → git commit → git push muscle memory. The agent handles the choreography; you approve the diff.

But the quieter change might matter more: Canvas now defaults to Kimi K3, tagged free. That's a top-tier reasoning model — Moonshot's latest — with zero API cost for OpenHands Cloud users. No BYOK. No credit card. Just works.

Add LLM pre-flight validation (catches misconfigured profiles before they burn a session), structured error outcomes in Canvas (you see what failed, not just that it failed), and a batch of backend fixes — this is the kind of release that shifts a tool from "interesting experiment" to "daily driver."

The Git Sync Page: Automation That Feels Obvious in Retrospect

OpenHands has had automations for a while — CI/CD triggers, scheduled runs, webhook handlers. But Git operations remained a manual dance. You'd finish a task, switch to terminal, commit, push, maybe open a PR. Friction adds up.

The new Git Sync page (Settings → Automations → Git Sync) changes that loop:

Visual diff review before any push — you see exactly what the agent staged
Branch switching without leaving the UI — handy when juggling feature/main/hotfix
Pull with rebase/merge options — the agent fetches upstream, resolves trivial conflicts, flags the rest
Commit message generation — optional, but the agent writes conventional commits from your session context

It's not magic. It's a thin wrapper around git with a diff viewer and approval gate. But that wrapper eliminates the context-switch tax. You stay in the conversation. The agent stays in context. The PR gets opened with a description that actually reflects what changed.

For teams running OpenHands Cloud, this also means auditability — every sync action is logged with the session that triggered it. Compliance teams love that.

Kimi K3 as Default Canvas Model: Free Tier Just Got Serious

Until 1.14, Canvas (OpenHands' visual coding interface) defaulted to a paid model or required BYOK. Now it ships with Kimi K3 — free, no key needed.

Quick refresher: Kimi K3 is Moonshot AI's latest reasoning model. 1M context window. Strong on code, math, long-horizon planning. Benchmarks put it near Claude 4 Sonnet / GPT-5 tier on coding tasks. OpenHands Cloud foots the inference bill.

What this means practically:

Scenario	Before 1.14	After 1.14
New user, no API keys	Stuck at provider setup	Works immediately
Student / hobbyist	Pay or self-host	Free tier viable
Team eval	"Who pays for tokens?"	Zero-cost pilot
Offline / air-gapped	Self-host only	Still self-host (unchanged)

The free tag in the model selector isn't marketing — it's a hard guarantee. No surprise bills. No rate-limit emails. If you hit quota, the UI tells you; it doesn't silently degrade.

You can still plug in your own keys (Anthropic, OpenAI, Google, custom endpoints). But the default path now just works for 90% of users.

LLM Pre-Flight Validation: Catch Config Errors Before They Burn Sessions

Ever start a 45-minute agent run, come back, and find it failed at minute 3 because the model endpoint returned 401? Or the context window was too small for the repo? Or the provider doesn't support tool calling?

1.14 adds a pre-flight check when you save an LLM profile:

Validates auth (key / OAuth / endpoint reachable)
Probes model capabilities (tool calling, vision, max tokens)
Warns if context window < 32k for code tasks
Flags unsupported parameter combinations

It runs in ~2 seconds. Green check = good to go. Red X = tells you exactly what to fix. No more "why is my agent ignoring tools?" debugging sessions.

Structured Error Outcomes in Canvas: See the Failure, Not Just the Stack Trace

Canvas errors used to surface as raw exception dumps. Helpful for maintainers. Useless for operators.

Now errors render as structured cards:

Error type (auth, rate-limit, context-overflow, tool-timeout, provider-down)
Recoverable? Yes/No with suggested action
Session state preserved — you can retry from the last clean turn
Cost impact — tokens consumed before failure (if tracked)

This matters because Canvas sessions run longer and cost more than chat turns. Knowing why it stopped — and whether retrying wastes money — changes the decision from "hope it works" to "fix the auth, retry."

Under the Hood: Fixes That Prevent Silent Session Death

The changelog lists bug fixes. Three stand out for daily users:

Preserve backend scope in conversation links — Deep-links to specific sessions/turns now work across cloud backends. Share a link; colleague sees the exact turn.
Stop baking absolute VITE_BACKEND_BASE_URL in npm run dev — Local dev no longer hardcodes prod URLs. Contributors can actually test against their fork.
Show full workspace file tree in Files tab on cloud backends — Previously truncated at 100 entries. Now recursive. Critical for large monorepos.

There's also a new Git Sync automation page (mentioned above), ready-for-dev issue gate with type-specific criteria, and conversation archive client-side (landed in 1.13, refined here).

Migration Notes: What Breaks, What Doesn't

Area	Impact	Action
Existing LLM profiles	None	Re-save to trigger pre-flight (optional)
Canvas sessions	Model default changes	Explicit model selection overrides default
Automations	New Git Sync page	No config migration needed
Cloud backend URLs	Dev env fix	Update local `.env` if you hardcoded
Docker images	`openhands-release-bot` signed	Pull `v1.14.0` — verified GPG

Self-hosters: docker pull ghcr.io/openhands/openhands:v1.14.0. The release is signed (GPG key B5690EEEBB952194). Verify with cosign verify if your pipeline demands it.

Why This Release Signals Maturity

OpenHands has been "the open-source Devin alternative" for a while. 1.14 feels like the first release where product polish leads over feature chase.

Git Sync solves a workflow pain, not a capability gap
Free Kimi K3 removes the adoption barrier for new users
Pre-flight validation prevents silent failures that erode trust
Structured errors turn frustration into actionable info

These are the things that make a tool survive the "try once, abandon" filter.

Should You Upgrade?

Cloud users: Automatic. Next session runs 1.14.

Self-hosted: Yes. Low risk. High reward (Git Sync, free model default, error UX).

Evaluating OpenHands: Best time to start. Zero-cost entry with Kimi K3. Git Sync means you can test the full loop — code → commit → push → PR — without leaving the UI.

Teams on BYOK: No rush. Your keys still work. But try the free model on a side project — you might save the budget.

The Bigger Picture: Open Source Agents Are Catching Up

Six months ago, the gap between commercial (Devin, Cursor, Copilot) and open (OpenHands, Goose, Aider) was capability. Today it's polish.

OpenHands 1.14 doesn't add a new reasoning paradigm. It adds the glue that makes the existing paradigm usable daily: Git integration that doesn't suck, a free model that doesn't hallucinate pricing, errors that tell you what to do.

That's how open source wins — not by being first, but by being the one you don't have to fight.

Quick Start: OpenHands Cloud (2 Minutes)

# No install. No keys. Browser only.
open https://app.openhands.ai
# Sign in with GitHub
# Pick a repo (or create new)
# Click "New Session" → Canvas opens with Kimi K3
# Type: "Add a health check endpoint to the API"
# Watch it write code, run tests, open Git Sync diff, push PR

Quick Start: Self-Hosted (Docker)

docker run -d \
  --name openhands \
  -p 3000:3000 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/home/openhands/.openhands \
  ghcr.io/openhands/openhands:v1.14.0

# Open http://localhost:3000
# Configure LLM profile (or use default Kimi K3 if cloud-connected)

TL;DR

OpenHands 1.14–1.17 = Git Sync UI + Free Kimi K3 as default + LLM provider switching + Linux desktop + Automations 2.0.

Git Sync: Commit/push/branch from the agent UI. Diff review built in.
Kimi K3 free: Top-tier reasoning model, zero cost, no key needed on Cloud.
1.15–1.17: LLM provider connections, Linux desktop installer, skills allow-list, conversation tags, automation permission split, custom cron expressions.
Pre-flight: Catches bad config before it burns a session.

Upgrade. Try it. The friction just dropped.

What the 1.15–1.17 wave added

Three releases followed 1.14 within three weeks, and they keep removing reasons to hesitate — especially for self-hosters in the middle of the open-source vs commercial decision:

LLM provider switching, anywhere. A provider-connections UI landed for the agent server (v1.15), then cloud-based LLM provider connections (v1.17). You can point Agent Canvas at OpenRouter, a local llama.cpp server, or anything OAuth-able — the analysis in persistent context applies: the harness matters more than the one model it ships with.
A real Linux desktop installer. Deb + CI fixes shipped in v1.16 — Agent Canvas is no longer a Docker-and-terminal-only project for people who want a windowed app on a home server.
Skills became an explicit allow-list. v1.16 replaced the all-on skill catalog with an opt-in list — a smaller prompt footprint and fewer surprises for beginners.
Conversation tags and filtering (v1.17) — organizing long-running sessions in the sidebar like issues in a tracker.
Automations got permissions. v1.17 split automation permissions into view/manage with a creator escape hatch, and added editable custom cron expressions. Combined with v1.15's ability to install a catalog entry that ships a script bundle, the automation stories people kept asking for are finally scriptable.
A telemetry off-switch — --disable-telemetry for self-hosted Canvas (v1.17).

The free-model story from 1.14 also held up: v1.16 fixed default/free model handling and v1.17 added LLM pre-flight validation to stop misconfigured profiles from burning a session — the exact kind of guardrail that matters when you hand a self-hosted agent your repo.

- Context Engineering for Coding Agents: How to Make Every Token Count

Using OpenHands 1.14? Hit reply — I'd love to hear if Git Sync changes your loop or if Kimi K3 holds up on your codebase.

Best Coding Agents 2026 — Decision Guide

TerminalBlog — Thu, 10 Sep 2026 04:33:40 +0000

- Coding agents vs GitHub Copilot: autocomplete is not an agent

"Best coding agent" is the wrong question. The right one is: best for your workflow, risk tolerance, and budget this quarter.

This guide is the decision pillar. It points at live data and deep comparisons instead of ranking tools we barely used.

Start with the job, not the brand

If you need…	Look first at…	Why
Interactive daily IDE speed	Cursor	Inline edits, repo-aware chat, habit fit
Deep multi-file reasoning in terminal	Claude Code	Strong on hard refactors; watch cost + isolation
Free / BYO keys, open harness	OpenCode, Hermes, Goose	Own the stack; more setup
GitHub-native CLI	Copilot CLI	Repo + Actions adjacency
Cloud parallel agents	Codex	Parallelism tradeoffs vs local control
Automation / cron / multi-provider	Hermes	Scheduling + routing features

Step 1 — Check real adoption (not vibes)

Use the live AI Coding Agent Leaderboard (npm downloads + GitHub stars + forks). High stars + low downloads often means hype ahead of habit.

Embed-friendly summary: leaderboard embed.

What the numbers actually tell you

npm downloads = developers actively installing and using the tool. This is the strongest signal of real adoption.

GitHub stars = developer interest and community endorsement. High stars with low downloads suggests the tool is impressive but not yet practical for daily use.

Forks = community contribution and customization. High forks means developers are extending and improving the tool.

Example interpretation:

Claude Code: High stars + high downloads = proven and popular
Hermes: High stars + moderate downloads = strong community, growing adoption
Some new tools: High stars + very low downloads = hype phase, wait for maturity

Step 2 — Feature fit

Full matrix: Coding agent features comparison 2026.

Minimum questions:

Vision / browser? Do you need to see screenshots or interact with web pages?
Multi-provider? Can you switch between Claude, GPT-4, Gemini, or local models?
Cron / background? Can it run automated tasks while you sleep?
Sandbox quality on YOUR OS (especially Windows)? Does it isolate sessions properly?
Plugin / skill model (AGENTS.md, skills, MCP)? Can you extend it with custom instructions?

Feature deep dives

For terminal-first developers:

Claude Code: Best reasoning, expensive
OpenCode: Free, extensible, requires setup
Hermes: Free, scheduling, multi-provider

For IDE-first developers:

Cursor: Fastest inline edits, best UX
Copilot CLI: GitHub integration, familiar workflow
Kilo Code: Lightweight, VS Code extension

For automation-first developers:

Hermes: Cron jobs, background tasks, multi-agent
Codex: Cloud parallelism, CI/CD integration
Goose: MCP support, tool integration

Step 3 — Security posture

Before production use, run the Coding Agent Security Checklist.

If an agent cannot isolate sessions or lies about sandboxing, it is not "best" for anything that touches secrets.

Security red flags

No session isolation — Agent A can see Agent B's work
No sandbox — Agent has full filesystem access
No permission model — Agent can do anything without approval
No audit trail — Can't see what Agent did
No kill switch — Can't stop a runaway task

Security green flags

Isolated sessions — Each task is independent
Sandboxed execution — Limited filesystem/network access
Permission prompts — Ask before destructive actions
Full audit log — See every command and file change
Human approval gates — Critical actions require confirmation

Step 4 — Real cost

Subscriptions are the sticker price. Token overhead is the real bill.

Cost comparison framework

Monthly cost calculation:

Agent subscription (if any): $0-200
API tokens (if BYO): $5-100
Context window waste: $0-50
Multi-agent overhead: $0-100

Example scenarios:

Light user (1hr/day): Free agent + free API = $0/month
Moderate user (3hrs/day): Claude Code $20 + API = $30/month
Heavy user (6hrs/day): Claude Code $100 + Cursor $100 = $200/month
Team lead (8hrs/day): Multiple subscriptions = $400+/month

Step 5 — Head-to-head pages that matter

Skip the auto-generated pairwise spam. Start here:

Per-tool deep dives

Want the full profile before you decide? These deep dives go one level deeper than a head-to-head — install model, extension story, and where each tool stands alone:

This week in coding agents

The ecosystem moves weekly, and this pillar moves with it. Here is what actually shifted in the last update cycle — the releases, launches, and community signals that change the "best agent" answer.

August–September 2026 cycle

Coding agent weekly 2026-08-31, 2026-08-24, 2026-08-17 and 2026-08-10 — the running digest of every release, tool, and pricing change worth tracking since the last refresh of this page
The AI coding agent race just flipped — Claude Code is now twice as popular as Copilot — the JetBrains survey that changed the adoption narrative
Meta just gave away a free coding agent model that runs on your laptop — a serious new free/local option for BYO-key users
NVIDIA dropped a 30B model built for agents that runs on one GPU — the local-model bar keeps rising
Google killed Gemini CLI — Antigravity 2.0 is the new terminal king — a free tier migrated en masse
Cursor got acquired by SpaceX — the agent war entered a new era
GitHub Copilot CLI made shared terminal sessions real — new collaboration default
OpenAI slashed GPT-5.6 prices 80% — coding agents got way cheaper — an economics shake-up you should read before picking a stack
Hermes v0.21: your bots talk to each other now — Bot Mode + bot-to-bot DMs for the free automation-first crowd
OpenHands v1.13 — free models + a context meter that stops token blowouts and v1.14: git sync + free Kimi

Earlier cycle (July–early August)

Coding agent weekly 2026-08-03 and 2026-07-27 — the running digest of every release, tool, and pricing change worth tracking
Hermes v0.19 — 80% faster ("Quicksilver") — the free agent just narrowed the speed gap with the paid tier
Grok Build — xAI's 17K-star coding agent — a serious new entrant for BYO-key users
Cline v4.1: SDK migration + five critical agent fixes and v3.25: deep planning focus chain + auto-compact
Meta Muse Code + Spark 1.2: persistent subagents, live automations
OpenHands Agent Canvas 1.10: persistent memory + automations
AWS Kiro Crew: autonomous engineering teams
Model musical chairs: developers are losing AI loyalty — why "best model" matters less than "best harness"
What devs say about the vibe-coded tool flood — the counterweight to every "one tool to rule them all" take
Cursor Router: intelligent model routing — how the IDE space is catching up on routing
Stop worrying which agent, start worrying about safety

If a tool ships a meaningful update this week, it goes in this section and the old links below never get removed. Prefer this URL over chasing release notes.

The curated comparison library

There are hundreds of head-to-head URLs on this site; most are auto-generated filler. These are the ones worth reading because they measure something real (token overhead, parallelism, IDE-vs-terminal fit) instead of restating feature lists:

Claude Code vs OpenCode: token overhead — the per-task cost difference between two free-ish stacks
Claude Code vs Cursor 2026 and the community take
Claude Code vs Codex: terminal battle
Codex vs Copilot CLI: terminal battle
Cursor vs Codex: IDE speed vs cloud parallelism
Cursor vs Copilot CLI: IDE vs terminal
Hermes vs Codex and Hermes vs Mimo
OpenCode vs Claude Code free agent
Coding agents vs GitHub Copilot: autocomplete is not an agent
Open source vs commercial: operator fit, not ideology

The meta-debates that change your pick

Some debates sit above any single tool comparison and are worth reading before you commit to a stack:

Your coding agent is a harness — the model is the commodity — the argument that harness quality beats model choice
The great coding agent consolidation: three deals in 2026 — the market is merging; your pick should survive it
Multi-agent orchestration over bigger models — when fleets beat a single brain
Coding agent fleets, not a single tool
Agentic orchestration topology 2026
Coding agents writing coding agents: the self-improvement loop
AGENTS.md makes any agent 10× smarter and the full AGENTS.md guide
Context engineering for coding agents 2026 — the skill that matters more than the tool
Build circuit-breakers into your agents and fixing agent amnesia

Bottom line on the meta-debates: if two tools are within ~10% on your daily tasks, pick the one with the better harness, instructions, and upgrade path — the model loyalty debate (developers losing AI loyalty) says model preference flips quarterly, but your workflow stays.

Recommended default stacks (2026)

Solo developer, paid OK:

Cursor daily + Claude Code for hard refactors + tight permissions
Budget: $40-200/month
Best for: Full-time developers who value speed

Open-source maximalist:

OpenCode or Hermes + local models where viable + strict sandbox
Budget: $0-50/month (API costs only)
Best for: Privacy-conscious developers, learning, experimentation

Enterprise / GitHub-heavy:

Copilot CLI + policy-controlled cloud agent; audit MCP ruthlessly
Budget: $10-40/seat/month
Best for: Teams already in GitHub ecosystem

Automation-first:

Hermes (or similar) with cron + human approval on write paths
Budget: $0-50/month
Best for: DevOps, CI/CD, repetitive tasks

Make any agent 10× better

The harness matters less than the instructions you feed it:

Decision checklist

Before choosing, answer these:

What's your primary workflow? IDE vs terminal vs automation
What's your budget? Free vs $20/month vs $200/month
What's your risk tolerance? Privacy vs convenience vs cost
What's your team size? Solo vs small team vs enterprise
What's your ecosystem? GitHub vs GitLab vs self-hosted

FAQ

Q1: What is the best coding agent in 2026?

There is no single winner — the honest answer is "the one that fits your workflow, risk tolerance, and budget this quarter." For daily IDE work, Cursor is the fastest. For deep multi-file reasoning in the terminal, Claude Code leads. For free, BYO-key automation with cron and multi-provider routing, Hermes and OpenCode are the strongest open-source options. The right choice is a workflow decision, not a ranking.

Q2: Is a free coding agent good enough for real work?

Yes, for most solo developers. OpenCode, Hermes, and Goose are free with your own API keys and handle real multi-file work. The tradeoff is setup: you manage keys, permissions, and sandboxing yourself. If you want zero setup and a polished experience, a $20/month subscription like Claude Code or Cursor is usually worth it.

Q3: Which coding agent is best for automation and cron jobs?

Hermes is the standout for scheduled automation — it has first-class cron jobs, background tasks, and multi-provider routing. pi.dev also supports long-running background agents. Most interactive-only CLIs are not built for unattended fleets, so treat them as pair tools rather than fleet workers.

Q4: How much should I expect to spend on coding agents?

Light use can be $0/month (free agent + free API tier). Moderate use runs about $20-30/month for one subscription plus API tokens. Heavy use with multiple agents runs $100-400+/month. The real cost driver is token overhead, not the sticker price — measure your actual usage before committing.

Q5: Are coding agents safe to run on production code?

Only with guardrails. Run the coding agent security checklist first: isolated sessions, sandboxed execution, permission prompts, audit logs, and human approval gates for destructive actions. An agent that cannot isolate sessions should not touch secrets.

Q6: Which agent has the fastest setup for a working session?

Copilot CLI is the smoothest if you already have a GitHub account — install, auth, done. Claude Code is close behind with one npm i -g @anthropic-ai/claude-code and an Anthropic login. For a zero-cost path, OpenCode and Hermes both take under five minutes plus an API key. The setup pillar walks all three paths end to end.

How we update this page

When adoption shifts or a security class breaks, we update this guide and the security checklist. Prefer this URL over random "best of" listicles.

Last updated: September 2026.

GitHub Copilot CLI Just Made Shared Terminal Sessions Real — Here's Why It Changes Everything

TerminalBlog — Tue, 08 Sep 2026 18:04:13 +0000

GitHub Copilot CLI 1.0.80 landed August 13 as a pre-release, and it quietly shipped the feature terminal users have wanted for years: Agent Host Protocol (AHP) — multiple terminals sharing one live agent session.

If you've ever wanted to start a coding task on your laptop, walk to your desk, and pick up exactly where you left off in another terminal — this is that release.

The Headline: Agent Host Protocol (AHP)

copilot --ahp starts a local host that runs the agent. Any number of terminals can copilot --ahp to attach to that same host. They all see the same session, the same turns, the same history — live.

# Terminal 1: start the host + session
copilot --ahp

# Terminal 2 (same machine, or SSH'd in): attach to it
copilot --ahp

Both terminals now stream the same agent output. You type in Terminal 2, the agent responds, Terminal 1 sees it instantly. ctrl+c in either terminal takes control back. ctrl+q queues your prompt for the next turn.

This isn't screen/tmux sharing. The agent runs once on the host. Terminals are just views. Close one, the agent keeps running. Open another, you're back in.

Why This Matters for Beginners

No more "which terminal was I in?" — one session, many windows
Pair programming without screen share — teammate SSHs in, copilot --ahp, you're both in the same agent
Long-running tasks survive disconnects — start a refactor, close laptop, reopen later, it's still going
Dev container / Codespace parity — same workflow locally and in the cloud

Cloud Sessions: Your Agent in a Codespace

/ahp codespace <name> forwards a Codespace's copilotd port to your local CLI. The session runs in the Codespace (with its compute, its dependencies, its network), but you drive it from your terminal.

/ahp codespace my-frontend-codespace

The session appears in your Sessions tab marked CS. Create new sessions on that Codespace with n. Close the tunnel with /ahp stop <name>.

/ahp cloud <environment-id> does the same for GitHub Mission Control environments — marked CLOUD in the source picker.

For a beginner, this means: your terminal workflow doesn't change when you move to cloud compute. Same commands, same session model, just bigger machines.

The Sessions Tab Got a Complete Redesign

The new source strip (press h to switch) shows every session source:

This CLI process (local)
Every AHP daemon you've connected to
Every Codespace / cloud environment

Each source shows its health — copilotd 0.6.5, responding / not responding. A host that dies announces it in the timeline. No more stale session ghosts.

Shared sessions show 2 clients (or more) in the Sessions tab and sidebar. You see when someone else is attached. Presence is announced on attach, refreshed on heartbeat.

MCP Servers Finally Work Reliably

Two fixes that matter if you use Model Context Protocol servers:

--enable-mcp-server re-enables MCP servers disabled in settings for the current run — no more editing config to test a server
30-second default timeout for MCP tool discovery — slow servers (large tool catalogs, cold starts) no longer time out before loading

Sandboxed MCP servers launched via npx or uvx now get:

A writable Copilot-owned package cache
Windows toolchain grants
Playwright browser grants

readonlyPaths nested inside your working directory now actually block writes from built-in file tools. The sandbox respects your intent.

Model & Plugin Updates

MAI Code 1.1 Flash added to the model roster
/plugin marketplace update [name] refreshes marketplace catalogs on demand
Agent Plugins spec plugins now read components only under com.github.copilot/ — plugin root is no longer scanned (breaking change for plugin authors, cleaner for users)

Quality-of-Life Fixes You'll Notice Daily

Annoyance	Fixed In 1.0.80
`--ahp` failing with "no host listening" when daemons are running	Now attaches to existing daemon automatically
`/clear` and `/new` hidden on AHP sessions	Now work on the host — other clients see the cleared session
Connection tokens (`wss://host?tkn=...`) printed in logs/transcripts	Now redacted everywhere — safe to share transcripts
AHP sessions always starting at host workspace root	Now start in your CLI's directory (if host covers it)
Host skills vanishing after relay reconnect	Fixed — snapshot omission no longer reads as "no skills"
Status line stuck on "Loading extensions" for remote sessions	Now reports "can't load extensions into session I don't own" immediately
`copilot init` silently dropping `--sandbox`/`--no-sandbox`	Flags now apply to init session
Footer AI credit total lagging behind subagent spend	Updates live as background agents spend
Unknown/retired settings cluttering config	Moved to actionable Problems tab in `/settings`
Enter sometimes leaving message in queue	Now always acts on your message
Very large sessions failing to load after rewind/compaction	Fixed

How to Update

# Prerelease channel (1.0.80-0)
npm install -g @github/copilot@prerelease

# Or via install script
wget -qO- https://gh.io/copilot-install | bash -s -- --prerelease

# Verify
copilot --version
# Should show 1.0.80-0

Note: --ahp and /ahp commands are gated on the AHP_CLIENT feature flag (staff-only for now). The rest of 1.0.80 is available to everyone.

What This Means for Your Workflow

If you're solo: Start copilot --ahp in one terminal. Open as many tabs/windows as you want — they're all the same session. Run a long task, detach, come back tomorrow.

If you pair program: Teammate runs copilot --ahp (same host). You both drive. No screen share latency, no "wait let me type."

If you use Codespaces: /ahp codespace <name> gives you local-terminal UX on cloud compute. Your session survives Codespace restarts.

If you run background automation: The host keeps running. Schedule a session to run overnight, check it from your phone via SSH + copilot --ahp.

The Bottom Line

Copilot CLI 1.0.80 isn't a feature drop. It's an architecture shift.

The agent moved out of the terminal and into a host process. Terminals became views. Sessions became portable across machines, clouds, and collaborators.

For a beginner, this means: learn the CLI once, use it everywhere. Local, remote, cloud, shared — same commands, same mental model.

The terminal agent just became collaborative infrastructure.

- Claude Code: Skills vs Subagents vs MCP — The 2026 Decision Guide

Release: GitHub Copilot CLI 1.0.80-0 · Changelog · Install

Comparing agents is half the work. *aiFiesta** can simplify multi-model access while you test workflows.*

OpenAI Just Slashed GPT-5.6 Prices 80% — Coding Agents Got Way Cheaper

TerminalBlog — Tue, 08 Sep 2026 18:03:54 +0000

OpenAI didn't announce it with a keynote. They just updated the pricing page.

GPT-5.6 Luna: 80% cheaper.

GPT-5.6 Terra: 20% cheaper.

GPT-5.6 Sol: 2.5x faster with new Fast mode (at 2x price).

Effective July 30 for Luna and Terra, August 21 for Sol's Fast mode. If you run coding agents — Cursor, Codex, Claude Code, OpenCode, Zed, any of them — your per-agent cost structure just shifted overnight.

The Numbers That Matter

Model	Old Price (per 1M tokens)	New Price (per 1M tokens)	Change
GPT-5.6 Sol	$5.00 / $30.00	$5.00 / $30.00	No change (base)
GPT-5.6 Sol Fast	N/A	$10.00 / $60.00	New tier: 2.5× speed
GPT-5.6 Terra	$2.50 / $15.00	$2.00 / $12.00	-20%
GPT-5.6 Luna	$1.00 / $6.00	$0.20 / $1.20	-80%

Cached reads stay at 90% discount. Cache writes cost 1.25× base input (new for GPT-5.6+). Minimum cache life: 30 minutes.

Why This Breaks the Old Cost Models

Most teams budget for agents like this: model cost × tokens per call × calls per day.

That math just broke.

Luna at $0.20 / $1.20 is effectively "too cheap to meter" for agent workflows

At the old $1.00 / $6.00, a 500-call daily workflow at 3K tokens/call cost ~$9/day. At new pricing: $1.80/day. That's $54/month → $2,600/year per developer saved.

Luna now undercuts GPT-5.4 nano ($0.20 / $1.25) while beating it on every agent benchmark. OpenAI's own data shows Luna at 84.7% on Terminal-Bench 2.1 — ahead of GPT-5.5 (85.6%) at 1/25th the cost.

Terra at $2.00 / $12.00 is the new "default production model" for coding agents

Terra scores 87.4% on Terminal-Bench 2.1 vs GPT-5.5's 85.6% — at 40% of GPT-5.5's price. For teams that need reliability over raw speed, Terra is now the obvious default. You'd need a specific failure mode to justify Sol.

Sol Fast mode (2.5× speed, 2× price) changes the latency/cost tradeoff

When you need answers now — debugging a production outage, unblocking a deploy — Fast mode delivers Sol quality at 2.5× throughput. The per-task cost is similar (2× price / 2.5× speed = 0.8× cost per unit time), but the wall-clock difference matters when humans are waiting.

What This Means for Your Agent Stack

If you use Cursor (ChatGPT Work / Codex)

Free/Go users: Terra is now your default — cheaper credits, same quota
Plus/Pro/Enterprise: You can route routine work to Luna, complex work to Terra, fire-drills to Sol Fast
Action: Check your Cursor model settings. Default may still be Sol.

If you use Codex CLI / ChatGPT Codex

Same tier access as Cursor
/fast flag in Codex now maps to Sol Fast mode
Action: Update your AGENTS.md or team docs with the new routing logic

If you use Claude Code / Anthropic API

Fable 5 still leads on long-context and instruction nuance (see our benchmark deep-dive)
But the price gap widened: Fable 5 at ~$15/$75 vs Terra at $2/$12 is 7.5× more expensive
Action: Keep Fable 5 for security-sensitive and long-context tasks. Move volume to Terra/Luna via OpenRouter or multi-provider setup.

If you use OpenCode / OpenRouter / BYOK setups

OpenRouter already reflects new pricing
Action: Re-run your cost projections. The "use the best model" advice is now "use the cheapest model that clears your quality bar"

If you self-host or use local models

The bar for "worth paying for API" just moved significantly higher
Luna at $0.20/$1.20 competes with GPU hour costs for small workloads
Action: Recalculate your break-even point

The New Agent Routing Logic (Steal This)

# Recommended model routing for coding agent teams (August 2026)

routine_refactoring: gpt-5.6-luna      # $0.20/$1.20 — 84.7% Terminal-Bench
feature_development: gpt-5.6-terra     # $2.00/$12.00 — 87.4% Terminal-Bench
security_review:     claude-fable-5    # Premium — long-context, safety
production_debug:    gpt-5.6-sol-fast  # $10/$60 — 2.5× speed when blocked
architecture_design: gpt-5.6-sol       # $5/$30 — max reasoning, no rush

The rule: Default to Luna. Escalate to Terra when quality dips. Escalate to Sol/Sol Fast only when you hit a documented failure mode. Reserve Claude for the 5% of tasks where its specific strengths pay off.

Hidden Gotchas

1. Cache writes now cost 1.25× base input

For GPT-5.6+, writing a cacheable prefix costs 25% more. But a single cache read (90% discount) pays it back. Design your prompts with explicit cache breakpoints — OpenAI added cache_breakpoint support in the Responses API for this exact reason.

2. Fast mode is not "Sol but faster" — it's a separate SKU

You opt in via processing_mode: "fast" in the API or /fast in Codex. It's not automatic. If your agent framework doesn't expose this, you're leaving speed on the table.

3. Subscription credit burn changed

ChatGPT Work and Codex subscribers: Terra and Luna now consume fewer credits per call. Your quota lasts longer. But Sol Fast burns credits 2× faster. Monitor your usage dashboard.

4. The "Sol = GPT-5.5 price" trap

GPT-5.5 is still $5/$30. GPT-5.6 Sol is $5/$30. But GPT-5.6 Sol beats GPT-5.5 on every coding benchmark. There is zero reason to use GPT-5.5 for new deployments.

The Bottom Line

The era of "agent costs are negligible" just became real.

At Luna pricing, a 10-person team running 5,000 agent calls/day spends ~$18/day on model costs. That's $540/month total — less than one senior engineer's daily rate.

The bottleneck is no longer model pricing. It's:

Context management efficiency
Prompt engineering quality
Agent loop design (how many calls per task)
Tool calling overhead

OpenAI just removed the last excuse for not running agents at scale.

What to Do Today

Audit your current model assignments — are you defaulting to Sol/Terra when Luna would work?
Update your team's AGENTS.md / model routing config — bake in the new tier logic
Enable cache breakpoints in your agent prompts if you use Responses API
Test Sol Fast mode on your slowest agent workflows — measure wall-clock improvement
Re-run your monthly cost projection — you'll likely cut 40-80% off the model line item

- Your AI Agents Config Directory Is Now the Most Dangerous Place on Your Machine

The pricing data in this article reflects OpenAI's official API pricing page as of August 21, 2026. Rates can change without notice. Always verify at developers.openai.com/api/docs/pricing before committing spend.

Hermes Agent v0.21 Just Made Your Bots Talk to Each Other — Here's What Changed

TerminalBlog — Tue, 08 Sep 2026 18:03:41 +0000

Hermes Agent v0.21.0, codenamed Pantheon, dropped on August 31, 2026 — and the name fits.

v0.20.0 made Hermes the "herald" — it could speak and carry messages to other agents. In v0.21.0, "the gods assemble." Your agents now form a society with names, faces, and group chats where they talk to each other and to you like teammates, not tools.

If you're new to coding agents, this is the release where multi-agent stopped meaning "plumbing" and started meaning "Discord server full of AI coworkers."

1. Bot Mode — your agents become a team, built in

The headline feature: Bot Mode is now bundled and on by default in the desktop app.

Every agent profile gets:

A name you choose
A deterministic avatar face (generated from the name, with randomize/lock controls)
A spot in a shared roster

You can create Discord-style group chats where multiple bots and you talk in one room. @-mention any bot from the composer. Give rooms names and pictures.

Before: Multi-agent meant writing config files, managing handoffs, and debugging why Agent A couldn't talk to Agent B.

After: It looks like a chat app full of coworkers. You create a room called "Code Review," add your "Reviewer Bot" and "Test Bot," and they discuss your PR while you watch — or jump in.

This is the biggest UX leap for beginners. You don't need to understand orchestration. You just invite bots to a room and ask them to work together.

2. `hermes peer` — bots can DM each other

Any Hermes agent can now message any other by handle, across profiles and gateways, from the CLI or from inside a conversation.

Example workflow:

Ask your Research Bot to investigate a library.
Tell it to hand findings to your Coding Bot.
The Coding Bot replies in its own Bot Chat — where you can read it.

The key detail: replies land in each agent's canonical Bot Chat, so conversations between agents are durable and inspectable. Not fire-and-forget. You can audit what they said to each other.

For beginners: this is like having specialists who pass work between themselves, but you stay in the loop because every conversation has a paper trail.

3. Cron jobs that actually remember

Scheduled jobs used to be goldfish — every run started from zero. Now:

Cron agents load and update persistent memory like every other agent
continuity=true carries each run's output into the next (so a monitor can dedupe against what it already reported)
Every job gets a durable notepad scratchpad
Monitor-mode jobs skip the LLM entirely when nothing changed (saves tokens)
Cron output can land in a bot's Bot Chat — where the bot actually responds

Your 9am briefing job now knows what it told you yesterday. Your security scanner remembers which issues it already flagged. This turns scheduled tasks from "dumb alarms" into "agents that learn."

4. Steer your subagents while they run

The delegate_task tool gained live orchestration:

List running children
Steer one mid-flight with a course correction
Stop it early and keep the partial result

Plus:

Optional JSON-schema validation on child outputs
Per-delegation cost surfaced in results
Raised defaults: 250 iterations, 10 concurrent children

Before, delegation was "fire and pray." Now it's managed parallel work. You can watch five subagents churning through tasks, nudge one that's going sideways, and pull results from another that finished early.

5. The MCP command center

MCP (Model Context Protocol) servers and the catalog merged into one coherent desktop page:

Drag-in "paste anything" import — paste a URL or config and Hermes figures it out
Background health checks — nudges you to re-auth before a tool call fails
Fleet cost/usage overlay — schema token estimates and 30-day usage per server
hermes:// deep links — install an MCP server with explicit confirmation

Managing twenty MCP servers used to be config-file archaeology. Now it's a dashboard. For beginners: MCP is how agents connect to external tools (databases, APIs, file systems). This update makes that connectivity visible and manageable.

6. The agent drives the desktop's browser

The in-app browser stopped being a window the agent could only look at. Hermes now:

Navigates, clicks, and reads it directly
Pages can be popped out to your system browser
Full link context menus

Ask it to walk a docs site or debug a web app and watch it happen inside your own app. This is huge for research workflows and debugging web interfaces.

7. CLI power wave

The terminal interface got a Ghostty-level polish pass:

Ctrl+P opens a fuzzy command palette
/model picker filters as you type
/status shows reasoning mode, pending approvals, and context usage
Status bar can display live cache-hit %, latency, and tokens/sec with per-field toggles
Global emergency stop
Session pin/unpin
Rotating task-oriented composer placeholders
Terminal pets — because a companion should have a companion

8. Security hardening across the board

Several quiet but important changes:

Protected agent-instruction files (AGENTS.md, skills, memory stores) now always require write approval — a prompt-injected agent can't quietly rewrite its own standing orders
Deep redaction sweep closed secret-leak gaps across terminal errors, .env file reads, checkpoints, and ACP logs
Approval system learned Windows destructive commands
macOS permission grants survive updates via a stable TCC signing identity

9. Six new providers and a model catalog wave

New built-in providers:

Meta Model API (Muse Spark)
CommandCode (GOAT/Pro/Max plans)
Tencent TokenPlan
Nebius Token Factory
Ramp Router
Actual Computer

New models in the pickers:

GLM-5.3-Flash
qwen3.8-max/flash
Gemini 3.7 Flash
MiniMax M3 free
Nemotron 3.5 Lightning

Plus model_overrides — patch any model's context window or pricing yourself without waiting on a release.

Also in this release

Data-training-tier warnings — unified selection-guard registry warns you across every picker surface when a model trains on your data
Pip-installed model providers discovered via entry points — third parties can ship providers as packages
TTL result caching for web_search/web_extract
Lean-tail compression as the default
Opt-in OS-keychain encryption for stored secrets (no more per-launch macOS Keychain prompts)

How to try it (beginner steps)

Update: Run hermes update if you already have it installed.
Try Bot Mode: Open the desktop app, create a new bot profile, give it a name, and watch its face generate. Create a room, add your bot, and start a conversation.
Set up a cron job that remembers: Use the cron system to schedule a task, enable continuity=true, and watch it learn from previous runs.
Steer a subagent: Delegate a task, then use the live orchestration controls to check on it mid-flight.
Explore the MCP dashboard: Open the MCP page in desktop and see all your connected tools in one place.

Bottom line

Pantheon is the release where Hermes stopped being "one agent you talk to" and became "a platform where multiple agents talk to each other — and to you."

Bot Mode, bot-to-bot DMs, cron memory, live subagent steering, and the MCP command center all point in the same direction: multi-agent is now a user experience, not an architecture problem.

If you've been waiting for coding agents to feel less like a REPL and more like a team, this is the one.

Hermes Agent is open-source (MIT) and available at github.com/NousResearch/hermes-agent.

Codex 0.147.0: Portable Plugins, Automatically Approved Reviews, and Safer Defaults

TerminalBlog — Fri, 07 Aug 2026 04:33:34 +0000

OpenAI shipped Codex 0.147.0 on August 7, 2026, a few days after 0.146.0 introduced Agent Plugins, named sessions, and thread forking. If 0.146.0 opened the door to an extensions ecosystem, 0.147.0 makes that ecosystem portable, adds an --approve-for-me flag that hands routine approvals to the agent itself, and quietly tightens security defaults in ways beginners should care about.

This is a beginner-friendly look at what changed, what it means, and how to use the headline features today.

Portable plugins: install once, use anywhere

The biggest practical upgrade is portable Agent Plugins. In 0.147.0, Codex can now install plugins and make them available across every place you run it — your personal machine, a workspace, a shared team project, or a remote host. Instead of a plugin living only in one folder, you can search a catalog and drop it into the scope where you actually need it.

Why this matters if you are new to Codex: before this release, a plugin you installed for one workspace did not automatically follow you to another. You had to reinstall or manually wire it up per project. Now Codex searches local, personal, workspace, and remote plugin catalogs, so the tools you already use show up regardless of where you are. It feels closer to how npm finds packages from anywhere on your system.

Using it looks like this:

# Search available plugin catalogs for a code-review tool
codex plugin search code-review

# Install into your personal catalog so it works in any project
codex plugin install <name> --scope personal

The exact catalog flags depend on your setup, but the mental model is one plugin install, many overlapping scopes — with Codex picking the most specific match for the project you are in.

`--approve-for-me`: let the agent approve routine reviews

Codex has an approval flow: before an agent edits, runs, or interacts with your machine, it asks you to say yes. That keeps humans in control, but for low-risk, repeated actions it can feel like an endless stream of prompts.

The new --approve-for-me CLI flag hands a slice of that to the agent. When you start Codex in this mode, it can automatically approve requests that fit the "automatically reviewed approvals" category — which are the ones you would click through anyway, like running a linter or applying a safe, small edit. You still approve anything genuinely sensitive.

For a beginner, the honest framing is: use it to remove friction only after you trust the session. A quick mental rule is to start a session in normal mode, and switch to auto-approve once the task is a mechanical repeat of something you have already okayed.

Import Cursor skills and merge conversations without duplicate mess

If you are evaluating Codex but have muscle memory (and skills) built in Cursor, 0.147.0 removes one of the big switching costs. Codex can now import Cursor-managed skills and, importantly, synchronize changes back to your imported Claude and Cursor conversations without creating duplicates. Instead of a one-way one-time import that copies everything and then drifts out of date, it keeps an eye on the originals and stays in sync.

This is a nice step toward a multi-agent workflow where you are not locked into one vendor — skills live wherever you like, and Agent Plugins bridge them across.

The MCP 2026-07-28 protocol: behind-the-scenes reliability

A chart-topper that you will not see but will feel: Codex adds opt-in support for the MCP 2026-07-28 protocol standard. That brings paginated tool discovery, multi-round requests, and non-blocking server startup. In plain language: more stable connections to external MCP servers, faster startup that no longer stalls your first turn, and the ability to fetch big tool lists in pages instead of all at once.

Install a few comparison fields — like MCP memory or Gmail — and you may notice fewer hangs and quicker mentions of servers becoming ready.

Safer defaults (read this part)

Two changes in 0.147.0 are worth reading for a beginner:

Requires explicit trust for unfamiliar projects. Before your credentials get used, Codex now requires you to trust a project you have not worked in before. That closes a real gap where an unfamiliar folder could silently consume your auth without a clear prompt.
Redacts secrets and bearer tokens. Commands you run and replayed history no longer show full secrets — Codex scrubs them from what is displayed. Combined with stricter plugin isolation (and a denial of network access if a policy update fails), the release is the most safety-conscious package update in a while.

The explicit-trust change is the one beginners should configure consciously. When you open a download repo, expect a "trust this project?" prompt. Treat that the way you would escalate permissions in any tool — trust only folders you own or from people you trust.

Getting started

Update to 0.147.0:

npm install -g @openai/codex
# or, for the standalone install
codex update

Then try auto-approving a low-risk session:

codex --approve-for-me

And for a repeating task with Cursor skills already built, run the import-step that imports your Cursor skills and lets Codex stay in sync with them.

The bottom line

Codex 0.147.0 is a release about daily feel more than headlines: portable plugins that follow you, fewer click-throughs on routine reviews, stronger safeguards by default, and smoother MCP connections. For someone just starting with a coding agent, the pair of features to care most about is --approve-for-me plus the explicit "trust this project?" prompt. Together they give you the speed of automation without handing over everything at once.

If you have not tried a terminal coding agent yet and want the security side sorted before experimenting, pairing a cautious default setup with the trust and redaction changes helps you stay safe while you learn.

Looking to compare AI models without switching tabs? *aiFiesta** gives you GPT, Claude, Gemini, Grok, DeepSeek, and Perplexity in one place for $12/mo.*

OpenHands Agent Canvas 1.10.0: Persistent Memory, Live Agent Activity, and a Friendlier Control Center for Beginners

TerminalBlog — Fri, 07 Aug 2026 04:32:46 +0000

OpenHands, the open-source AI development project with over 83,000 GitHub stars, released Agent Canvas 1.10.0 on August 5, 2026. On its own, 1.10.0 looks like a small polish release — a new default model here, an export button there. But bundled with the releases that led up to it, it continues a clear push to make self-hosted coding agents feel more reliable and easier for newcomers to control.

If you are new to OpenHands — or you have been wondering whether it is worth trying over Claude Code or Codex — this article explains what the project is, what 1.10.0 actually changed, and why the small updates matter more than a version bump suggests.

What OpenHands Is (If You Are New)

OpenHands now brands itself as Agent Canvas: a self-hosted "control center" for AI coding agents. Instead of just being one more terminal agent, it is a web app that runs on your machine (or a server) and lets you start conversations, review what the agent did, and set up recurring automations.

Key facts:

It runs the open-source OpenHands agent out of the box, but can also drive Claude Code, Codex, Gemini, or any agent that speaks ACP (Agent-Client Protocol).
It is self-hosted by default — your code and prompts stay on your hardware unless you opt into OpenHands Cloud.
You can run the agent locally, in a Docker container, on a VM, or on a cloud server, and switch backends from the same interface.

For beginners, the practical draw is one UI that lets you watch, pause, and automate an agent instead of trusting it blindly against your whole filesystem.

What's Actually New in the Recent Release Cycle

Version numbers come fast (1.8 → 1.9 → 1.10 within a week), so here are the changes that matter for a newcomer, in plain language.

1. Persistent agent memory (the headline feature)

In the 1.7.0 cycle, OpenHands added a persistent agent memory toggle. Instead of forgetting everything between chats, the agent can keep a short-term memory across sessions. For a beginner this is a genuinely useful quality-of-life change: you no longer have to re-explain your project layout, your naming conventions, or your goals every single conversation.

2. You can finally see what the agent is doing, live

1.9.0 added live agent activity in the chat view, and 1.10.0 adds an activity log export. This is a small thing with a big trust benefit. When a coding agent runs with full filesystem access, "trust but verify" is the only sane approach. Being able to see the agent's steps as they happen — and export a log later for review — gives you a transparency layer you previously did not get in self-hosted setups.

3. Automations get a proper dashboard

OpenHands lets you set up agents that run on a schedule or in response to events (a Slack message, a new GitHub issue, a webhook). 1.10.0 ships a featured automations landing dashboard and adds manifest-driven sub-pages, so the whole flow of creating, browsing, and enabling automations is closer to a proper product and less like fiddling with config.

4. MCP server controls and creds stay put

MCP (Model Context Protocol) servers are how agents get extra tools. OpenHands already lets you enable/disable an installed MCP server from its card; the latest release also fixes a real foot-gun: MCP credentials are preserved during the editor's mutations, so tweaking a server's config no longer silently drops a secret-like API key you plugged in.

5. A new out-of-the-box default model

1.10.0 sets the Canvas default to GLM 5.2. If you do not pick a model, this is what your agent uses. Model choice still comes per project — the default matters mainly because a sensible, cheaper model right off the bat lowers the "wow, this cost me money" surprise for first-time users.

6. Skills surfaces

OpenHands keeps its skills filter with a faceted rail in 1.10.0, and earlier fixes stopped disabled skills from being loaded into the agent's context. Put simply, the project is cleaning up context/bloat so your agent reads less irrelevant noise and works on exactly what you asked.

How To Try It (Three Ways)

Option 1 — fastest (no sandbox), thinking beware: runs the agent directly on your machine with full filesystem access.

npm install -g @openhands/agent-canvas
agent-canvas

Option 2 — safer, with a Docker sandbox: the agent only sees the folder you give it.

export PROJECTS_PATH="$HOME/projects"   # folders the agent may touch
mkdir -p "$PROJECTS_PATH" "$HOME/.openhands"
docker run -it --rm -p 8000:8000 \
  -v "$HOME/.openhands:/home/openhands/.openhands" \
  -v "${PROJECTS_PATH}:/projects" \
  ghcr.io/openhands/agent-canvas:1.9.0

Option 3 — from source: clone OpenHands/OpenHands, run npm install then npm run dev, and open http://localhost:8000.

At a Glance

Feature	Where it landed	Why it matters for you
Persistent agent memory	1.7.0	Agent remembers project context between chats
Live activity + activity-log export	1.9 / 1.10	You can see/verify what the agent is doing
Automations dashboard	1.10.0	Recurring agents are easier to set up and manage
MCP credentials preserved	1.10.0	Editing config no longer drops secrets
GLM 5.2 default model	1.10.0	Cheaper, safer default out of the box
Skills context cleanup	1.8–1.10	Less token noise, sharper behavior

Bottom Line

1.10.0 is not an earth-shattering release on its own — most commits are UI and internal plumbing. But read together with the persistent-memory work and the live activity view, the direction is clear: OpenHands is spending its effort on visible control, verified behavior, and lower cost of entry for self-hosted agents. For a beginner, that is exactly the right place to spend it.

Start with the Docker sandbox option so the agent lives in a box you can throw away, enable persistent memory once you trust it, and use the activity log to review what it did before you ever merge. That pattern keeps the power of a coding agent without giving an autonomous process free rein over your machine.

New here? Start reading next:

How to Set Up AI Coding Agents — Beginner's Guide

TerminalBlog — Fri, 07 Aug 2026 04:32:39 +0000

Also read: Best coding agents decision guide · Security checklist · Pricing guide

What you are actually setting up

A coding agent is a program that turns a natural-language instruction into real edits, commands, and git operations. Most beginners assume it is "a smarter autocomplete." It is not. It is a process with a shell, a filesystem, a git client, and your environment variables. That distinction drives every setup decision below, especially security.

Before you install anything, decide which kind of thing you want:

Terminal agent — you type instructions in your command line, it plans multi-file edits and runs them. Best if you live in a terminal. Examples: Claude Code, Codex, OpenCode, Hermes, Goose, Copilot CLI.
IDE agent — it lives inside your editor, sees your repo, and edits in place. Best if you want visual, inline diffs. Examples: Cursor, Kilo Code, Mimo Code.
Hybrid / automation agent — runs unattended on a schedule or across providers. Best for DevOps. Examples: Hermes (cron), Codex (cloud parallelism), pi.dev.

Not sure which fits? Read how the agents differ and the decision guide before you spend a minute installing.

Step 1 — Decide free vs paid, and pick your first agent

Your first agent should be one, not five. Pick the cheapest thing that covers your daily workflow, then add agents only when a gap shows. A common beginner mistake is signing up for four $20 subscriptions on day one. The cheapest and most honest start for most people is a free, BYO-key terminal agent (OpenCode or Hermes) or the cheapest subscription tier of Claude Code or Cursor.

Step 2 — Install your agent

Installing differs by tool, but the shape is identical everywhere: you download a binary or clone a repo, run a one-line installer, and get a prompt. Here are the per-tool install-and-first-run deep dives:

If you are on Windows, read why Windows is the awkward child for coding agents before you blame yourself. Most hang-ups on Windows come from sandbox and permission quirks that are documented fixes, not your fault.

Step 3 — Add the model keys (BYO vs. bundled)

Bundled subscription agents (Claude Code, Cursor): sign in, done. No keys to manage.
BYO-key agents (OpenCode, Hermes, Goose, Kilo, Mimo): you paste in an API key from Anthropic, OpenAI, Google, or OpenRouter. Keep keys out of the codebase and out of shared .env files.
Local models (Ollama): everything stays on your machine. See the full run agents on local models guide.
No install at all: run a coding agent in the browser via Google AI Studio's GitHub autodeploy.

The easiest portable option when you are testing multiple models is a single multi-provider key like OpenRouter — one credential that reaches many models, instead of managing a different key per model vendor.

Step 4 — Harden it before you trust it

An agent inherits everything your shell can reach. Do not skip this. At bare minimum, before your first real task:

Turn off auto-approve for destructive commands.
Verify session isolation actually works — do not trust a "sandbox enabled" toggle.
Keep API keys in a scoped env, not in the repo.

The full, runnable version is the coding agent security checklist. It is short and every check ends in a command you can paste. Also read what your coding agent knows about your codebase so you know what you are handing it.

Step 5 — Write an AGENTS.md and give it context

The single biggest quality multiplier is the instruction file you give the agent — not the tool brand. A well-written AGENTS.md tells the agent your project's conventions, architecture, and rules, and makes even a basic free agent feel 10x smarter.

Without this step, you are using a powerful tool with no instructions and blaming it for being generic. Spend the 30 minutes on an AGENTS.md.

Step 6 — Make it reliable: checkpoints, memory, and review

Once the first task works, harden the flow:

Checkpoint before every run. git stash push -u -m "pre-agent" — a stash is cheaper than a postmortem. If you hit a lock or stale-state hang, see Claude Code lock / workflow fixes.
Add guardrails first, not later. Agents can trip your EDR rules like attackers and leak secrets in surprising ways (security hardening wave). Build circuit-breakers so a runaway task stops itself.
Deal with memory. Agents forget context between sessions. Learn the memory tools and fixes and how Hermes persists context across sessions.
Add skills/plugins. Most terminal agents accept plugins or skills to extend them (Hermes skill system).
Automate the boring parts. Move recurring maintenance (deps, audits, PR checks) into cron jobs and automated code review.

Step 7 — Your first real task

Start small, on a test repo, with human approval on: fix a lint error, add one test, rename a variable across a module (but never in main). Most first runs are far easier on a throwaway branch. Expect the first session to feel slower than you'd like — that is normal. The setup minutes you invest in steps 4 and 5 pay back on every later run, and skipping them is why beginners quit their agent after a week and call it a toy.

Your 30-second first-run sanity check: the agent survives a short task end-to-end, you can see every command it wants to run before it runs it, and a git status after the task shows exactly the files you expected — nothing else.

The six-month view

Once you have one agent working, most people do not want to rip it out; they layer. The field-tested version of that is a three-layer setup (fast edits in an IDE agent + deep refactors in a terminal agent + schedule in an automation twin). Read how one operator runs it after 6 months and why they stopped using a single agent:

Beginner mistakes that waste the first week

Skipping AGENTS.md — the top quality lever, and the most skipped. Fix first.
Trusting the sandbox toggle. Verify it. This is the top cause of leaked secrets for new users.
Running on main with auto-approve on during the first week. Use a branch.
Collecting three agents thinking one is strictly better. Multitool without a plan doubles the failure surface.
Paying for a tier you never use. Start free; add the $20 tier only after you hit a real limit (pricing guide).

FAQ

Q1: Do I need a GitHub account to use a coding agent? Not for most local agents, but a GitHub account helps for Copilot CLI, Codex cloud parallel execution, and most of the ecosystem. The exception is fully local setup with Ollama.

Q2: What's the cheapest way to start? A free BYO-key terminal agent like OpenCode or Hermes with a single API key and a free-tier model can run at $0/month for light usage. See the pricing guide for budgets.

Q3: How important is the sandbox for a beginner? More important than the model you choose. A coding agent is a process with your environment; without isolation, a mistake can wipe a repo or leak a token. Run the security checklist before the first real task.

Q4: Which agent is easiest to set up? Terminal-first: Copilot CLI is the smoothest if you already have a GitHub account; for zero-cost, OpenCode and Hermes take a few minutes but need keys. IDE-first: Cursor installs like an editor and needs no API keys. See the decision guide.

Q5: I'm on Windows and nothing works. Read the Windows stepchild deep dive. Windows sandbox and permission gaps cause most hang-ups; the fix posts there cover the top failure modes.

How we update this page

During each weekly sync we add every new setup / how-to / installation post so it stays the one entry point. We never delete an existing link. Watch the Weekly digest (e.g. coding agent weekly 2026-08-03) to see what the agents shipped last cycle.

Last updated: August 2026.

Meta's Muse Code: A Battery of Persistent Subagents, Replay-Safe Runtime

TerminalBlog — Thu, 06 Aug 2026 20:40:51 +0000

Meta released Muse Code (beta) on August 6, 2026: a terminal coding agent powered by the new Muse Spark 1.2 model. It is Meta's real entry into the terminal-agent race, and it does not just clone Claude Code. Two design decisions stand out — a battery of persistent async background agents and a replay-exact, restart-safe event log — and they quietly address the two things operators actually complain about with current agents: redundant context gathering and sessions that die on a crash.

Here is what changed and why it matters if you evaluate or run terminal coding agents.

The One-Line Summary

Muse Code runs in the terminal (macOS and Linux), plans changes across large repos, writes code, and validates results — the standard harness job. The differentiator is its runtime architecture rather than any single feature. It coordinates multiple persistent subagents that stay alive for the whole session instead of spawning short-lived ones per task, and it records every model call, tool run, approval, and edit to a local event log that makes the whole run replay-exact and restart-safe.

Neither idea is brand new in isolation — persistent background agents appeared in OpenCode and Claude Code's recent releases — but Meta's framing treats them as the core design rather than an add-on, and co-trains the model specifically so it behaves best inside this harness.

Persistent Background Agents, Not Spawned-On-Demand

Most agents today use a simple "spawn a subagent for this task, get the result, throw it away" cycle. Muse Code inverts that: a set of async background agents remain active throughout the session, rather than being created for individual tasks.

Why this matters in practice:

Less redundant information gathering. A fresh subagent re-reads the codebase to build context from scratch every time. A persistent agent already holds that context, so multi-step tasks spend fewer tokens and less wall-clock time locating what they need.
Less steering. The background agents decide when to communicate back to the main agent instead of dumping every intermediate step on you. On a long refactor, that keeps your terminal quiet until there is a decision that actually needs a human.
Mixed latency. Because the subagents are already warm, follow-up steps on multi-step work start immediately rather than after a full context-reload.

The default skills ship with the pattern baked in. /plan turns a task into an approval-gated plan, /grill stress-tests that plan until it holds up, and /goal drives work toward a completed objective. Translated: plan, pressure-test the plan, then execute toward the finish line — a workflow that benefits exactly from having a record that the same agents can act on.

For a quick primer: if you have used Claude Code's --background-subagents or OpenCode's orchestration, you already have the mental model. Muse Code just makes persistent agents the default locomotion instead of an opt-in performance feature.

Replay-Exact, Restart-Safe Runtime

The second big change is quieter but maybe more important for long-running work. Muse Code keeps a local event log to which every model call, tool run, approval, and edit is appended. One file becomes the single source of truth for the session.

The consequence is that the runtime is replay-exact and restart-safe: if the process crashes, the agent can resume precisely where it stopped instead of losing the thread and silently derailing. For anyone who has lost hours to a 2-hour session that corrupted on a network blip or a closed lid, this is the feature set you actually wanted — checkpointing without manual orchestration.

This pairs naturally with the company's marketing of the same model + harness. Contrast with a generic agent that has no durable event log: a crash means the next run re-reads context and re-builds everything, burning tokens and losing decisions. With a restart-safe log, long-horizon tasks survive interruptions without you babysitting retries.

Spark 1.2 Was Co-Trained With Muse Code

Muse Spark 1.2 is a coding-focused update to the mid-2026 Spark 1.1 line, with gains in code generation, complex debugging, codebase understanding, and end-to-end workflows. The pricing framing readers saw in Meta's earlier Spark 1.1 API story (aggressively cheap inference) still applies to the model family story, but the model alone is only half the release here.

The important coordination: Muse Spark 1.2 was co-trained with Muse Code using rejection-sampled harness trajectories and recipe optimizations for goal conditioning, compaction, and subagent use, plus integration of the Muse Code toolset to maximize harness compatibility. In plain terms, the training objective bakes in behavior designed for the specific persistent-subagent, event-log harness — not just "give good code," but "give good code that works well through Muse Code's long-horizon loop." If you evaluate the model on a raw browser bench, you will miss the point of the co-training.

Two training directions worth noting:

Long-horizon training. Spark 1.2 was trained on whole-repository generation, large end-to-end projects, and auto-research, using planning to sequence work, goal conditioning to hold direction, and context compaction to retain knowledge across long runs.
A self-improvement loop. The team used Spark 1.1 to generate challenge environments and templates, then had it grade candidate solutions, producing a scalable training set for 1.2. That loop is why the model handles concrete long-horizon follow-through.

The case study in the release is a GPU-KDA kernel optimization run of 1,000+ tool calls (up to 24 hours), writing, compiling, profiling, and improving over baseline. The agent held a multi-hour, multi-thousand-call loop and kept improving — emblematic of what the persistent, replay-safe runtime is for.

What It Means for the Terminal Coder

Three practical takeaways for operators and evaluators:

Context costs less. If your pain is agents re-reading your repo every few minutes, the persistent subagent pattern directly targets that. It is worth benchmarking Muse Code against your current default specifically on a task that requires the second and third follow-up edits to a large file, where context is the bottleneck.
Sessions are safer. The replay-exact log means a crash does not nuke the work. Since long multi-hour runs are the organic habitat for this class of task, that is a real advantage even if nothing else sways you.
The frontier is now model-plus-harness. Whereas 2025 treated "the best model" as almost the whole story, 2026 is increasingly co-training the model to live inside a specific harness — Muse does this with Spark 1.2. Evaluation now has to benchmark the coupling, not the model on the bench or the harness in a vacuum. That is the deeper takeaway this release anchors.

Watch the builder: make the model and harness a matched flagship pair, and the lock-in argument shifts from "my model is smart" to "my harness understands my model." Muse Code is a round stake in that camp.

The Watch List

Three things to verify before the beta earns a slot in a serious stack:

Platform. Muse Code's installer targets macOS and Linux on day one. Windows users are out until there is a native path — same gap several terminal agents spent 2026 closing.
Model access and cost. Spark 1.2 is available in Muse Code and in the Meta Model API. If the earlier Spark 1.1 API pricing story holds as a pattern, expect the cheap-inference position to carry over — but confirm the Muse Code access tier yourself rather than assuming it.
It is a co-trained beta, not a dashboard. The interesting parts of this release are architectural (persistent agents, replay-exact logs) and hold up on a disposable repo you are happy to churn. Test it with approval-gated plan mode first, in a throwaway clone, before pointing it at a repo your livelihood depends on. Early betas earning trust is how a terminal agent gets adopted; Muse is still in the earning phase.

The signal worth taking away is directional. Terminal agents are converging on two things: warm persistent context instead of per-task context reloads, and durable run state instead of sessions that die. Muse Code ships both as defaults, not add-ons — that is a genuine step, even at beta quality, in the direction the whole category is already marching.

What Developers Think About the Vibe-Coded Tool Flood — From 40 HN Comments

TerminalBlog — Thu, 06 Aug 2026 20:40:05 +0000

If you follow Hacker News, you have seen the pattern: a coding agent ships something, someone builds a small wrapper around it — a session manager, a security scanner, a debugging helper — and the Show HN post arrives half an hour later. A year ago this felt like momentum. This week, developers pushed back hard, and the argument has a lot to teach anyone who uses AI coding tools.

Over the past few days, several small threads about coding-agent utilities — terminal session managers, open-source security scanners, read-only production debuggers — crisscrossed into a single, unusually candid argument about what these tools, and their authors, have become. The loudest take, repeated across threads in different words: with AI writing the code, a working repo is no longer proof of quality, and the front page is filling up with "vibe-coded" projects nobody is willing to maintain.

Here is exactly what everyone argued, who was right, and what it means if you rely on AI agents for your own work.

Context first (for anyone new here)

Two terms matter. Vibe coding is when you tell an AI agent what you want in plain English and let it generate most of the code — you review and adjust the result, but the agent does the heavy lifting. It is the fastest way to build a small utility that exists by the evening.

Now, the week on HN. Someone posted Wallfacer, a terminal "session manager for Claude Code" that lets you search and resume old agent sessions. Someone else posted Ship Safe, an open-source scanner that reviews what a coding agent is about to change in your repo. A third team launched HyperProbe, agents that attach read-only "probes" to a running service to inspect variables during production debugging. Individually, all three are useful. None of them is large, enterprise software — each is the kind of thing one person could knock out quickly with an agent.

The reactions under these posts were not the generous praise you might expect. They were a two-sided argument about whether these posts are valuable open-source collaboration or the software equivalent of an influencer posting a photo of their lunch.

Reaction 1: "Code is no longer effort"

The most repeated sentiment was that the old way developers evaluated an open source project broke. In the past, a working, well-structured repository was the main proof of competence. Commenters argued that equation died the moment AI models can write all of that code.

One developer, paraphrased: "In a world where code is cheap, code no longer equals effort. What I look at now are signals you cannot fake: consistency, attention to detail, long-term support, genuine community engagement. Until I see those, a new repo is just noise."

That is worth stopping on. It means experienced developers no longer scan a screenshot or a slick README and conclude "this is good software." They have started treating code alone as close to a red flag, and instead weighing whether the person behind it stayed around, answered issues, and kept the thing alive.

Reaction 2: "Every new tool is something I could build myself"

The strongest rejection came from a developer who framed the whole situation against the broader state of 2026:

"Why should I adopt someone's vibe-coded tool when I can vibe-code my own, tailored exactly to my use case, in under a day? I will never vibe-code the things I actually depend on — I do not want to maintain my own Kubernetes fork, and I happily pay for enterprise software. But these small end-user console apps are just noise. Posting it on Hacker News is the software developer equivalent of an influencer posting a picture of their lunch."

That last line got a lot of traction. The core point is practical: the tools themselves are now trivial to reproduce, because the hard work no longer lives in the code. What a developer needs to trust lives around the code — correctness, durability, and a person who will maintain it for years rather than abandon it after launch week.

Reaction 3: The rebuttals — "this is the upside"

It was not a doom-and-gloom thread. Several developers pushed back with a more optimistic read.

One noted: "I built a tool to manage my multiple agent swarms across Claude Code, Codex, and OpenCode — with conversation queuing and team sharing — and it took me the better part of a day. It is now deeply woven into how we work. This is the upside of the current world." The point: the same cheap code that produces "noise" can also supercharge your own team via correctly scoped internal tools — no public release required.

A different, free-software flavor of the rebuttal arrived when one user asked whether all this was simply the open-source dream — "fork it and make it your own." The reply: "That reduces open source to free beer, not free speech. Open source was always about a collaborative engineering process — we bet on the system together. What we have done now is reduce it to modern individualism, where everyone ships a private throwaway fork and nobody holds the community."

That exchange is arguably the heart of it all. Cheap code has made it easier than ever for one person to build something that works. But it has also made it easier for everyone to build and ignore, so the shared, maintained, sustainable layer that "open source" used to mean is thinning out.

Real insight: trust has moved out of the code

Step back and the recurring threads merge into one finding. Developers are not angry that AI can write code. They are angry that the thing they used to judge quality by — the code itself — is now free, so low-effort projects that would never win a maintainer survive anyway. The only signals now capable of separating "worth using" from "surely not even worth a star" live entirely outside the code: who maintains it, how long they stick around, and whether the tool solves a problem nobody already solved with better care. A new "AI specialist" appearing every week is being met with boredom.

This is not a niche complaint. One commenter framed it in volume terms: "Everybody can be a coder now — coding is the new crypto or NFT rush. GitHub added tens of thousands of new people last year, with hundreds of thousands of new repositories every day. I have stopped pre-sorting and decided to let the crowd and the maintenance record decide what is useful."

What it means for you

If you use coding agents day to day, this argument lands somewhere uncomfortable — and useful.

Having code quickly is only a small step. Whether you build your own helper or pull in one of the tools posted on HN, the deliverable is whatever happens after the first working version: shipping, testing, fixing, and maintaining. That part cannot be vibe-coded, and it is exactly where most of these projects quietly die.
Your own "slop" has a place — internally. Half of these threads happily pointed out the real win: building internal, scoped tools tailored to how your team already works, in hours, is one of the best things about the agent era. Do it — just keep them internal and focused, and drop the expectation that they belong on a front page.
Trust maintainers, not screenshots. The most practical guidance in these threads is simple: choose agent tooling on metrics of durability — commit history, open issues, how long the authors has been keeping the repo alive — over how polished the page looks. In 2026 a beautiful "agent-built" page is cheap; a repo that is still genuinely supported a year later is the real signal.

Bottom line. Coding agents are doing something nobody quite expected: they made the code itself trivial, and in doing so they shifted where credibility lives. The "vibe-coded slop" complaint you read on HN is really a signal about the world we are in now — everyone can build, so the only thing that separates a hobby from a product is whether someone keeps you the engine running. If you know the code is now cheap, you are hours ahead of the people who are still measuring quality by line count.

The right way to use this moment is not to worry about the flood. It is to realize that the quality you used to hide inside your code now has to live literally everywhere around it.

AWS Kiro Crew: Turning AI Coding Agents Into Autonomous Engineering Teams

TerminalBlog — Thu, 06 Aug 2026 20:40:01 +0000

AWS just made its biggest bet yet on autonomous engineering. On August 4, 2026, the company released Kiro Crew, an open-source orchestration platform designed to turn interactive coding assistants into long-running, self-managing engineering teams. It is not another AI coding agent. It is the layer around agents — the thing that coordinates them, remembers context across sessions, schedules their work, and gates what they're allowed to touch.

For anyone running coding agents in 2026 — not just tinkering with them — this is worth understanding. Kiro Crew is one of the first mainstream attempts to answer a question the industry has been circling all year: once an agent can reliably finish a single task, how do you make a team of them finish a week of work while you sleep?

What Kiro Crew actually is

Kiro Crew was born inside Amazon as an internal project called MeshClaw — the sort of tool Amazon builders often build quietly and never ship. This one got out of the building: more than 39,000 Amazon engineers adopted it in under six months before AWS decided to open-source it. That internal track record is the strongest signal the project has, and it's worth weighing against the marketing.

As launched, Kiro Crew is an application layer built to sit on top of existing coding agents. Its job is to make work bigger than a single task in a single session actually happen. Instead of an agent that does one thing then stops, you get an always-on workspace that can:

Coordinate multiple agents working on the same repositories and workflows.
Keep persistent memory across sessions, so the context you built last week isn't lost today.
Schedule recurring work — dependency upgrades, flaky test cleanup, framework migrations that run over hours.
Connect to developer tooling to investigate incidents, monitor pull requests, and triage issue queues.
Gate everything behind human approval workflows and security controls, and log what ran with signed audit logs.

You manage it through a web and desktop dashboard, so the agents keep running while you're in meetings, off the clock, or asleep. Developers return to completed progress rather than a stalled process.

How it's different from just another agent

The key distinction is that Kiro Crew is an orchestrator, not a model or a single agent. The model is a commodity. The harness — the coordination layer — is where the leverage moved in 2026. That's exactly what Kiro Crew monetizes conceptually, except it's free and open source.

Three architectural choices set it apart:

1. Persistent memory across sessions. A long-running engineering task isn't one prompt. It's a chain of investigations, decisions, and fixes that span days. Kiro Crew ships persistent memory as a first-class feature so an agent can resume where it left off instead of re-deriving everything from scratch.

2. Built on open standards — with a catch. The platform is built around two open protocols: Agent Client Protocol (ACP) and Model Context Protocol (MCP). That means it's designed to interoperate with the broader agent ecosystem. However, at launch Kiro Crew runs on the proprietary Kiro CLI, which is metered by credits. As one analyst put it bluntly in coverage: until someone runs a different agent under Crew and shows it working, "the open part stops at the orchestration layer." Claude Code, Codex, and Devin users may need to build and validate their own connectors before Kiro Crew can drive them.

3. Deploy it where you want. Kiro Crew runs entirely inside your environment — laptops, containers, or virtual machines — with no AWS account and no AWS-managed control plane required. For enterprises that care about where their agent traffic lives, that's a real feature: code and credentials can stay inside your own perimeter rather than going to a black-box.

The project is governed openly — a publicly listed steering committee, with proposals submitted as pull requests and debated in the open, following the same open governance model AWS used for OpenSearch and other OSS projects.

The reference apps set the shape

To make it concrete, AWS is launching three reference applications built on top of Kiro Crew:

DevFleets — worktree management, so multiple agent workers can operate on parallel copies of a repository without colliding.
Issue Radar — issue and pull-request triage, turning an agent into a first-pass filter for a growing ticket queue.
Task Runner — executing long-running engineering tasks that need checkpoints and retries.

These aren't standalone products. They're purpose-built UIs bolted onto Kiro Crew's orchestration engine, and AWS expects to ship more of them over time. The pattern matters more than any single app: AWS is betting that the winning model is not one bloated all-in-one agent, but a thin coordination layer plus specialized agents and tools wired into it.

Where it fits (and where it doesn't)

The strongest use cases, per the analyst reaction, are platform engineering, DevOps, and SRE — the work that's repetitive and long-running rather than novel. Dependency upgrades, framework migrations, flaky test cleanup, first-pass incident investigation, ticket triage. These are exactly the tasks that make sense to run asynchronously with checkpoints and retries, unbothered over hours.

Where it's weaker today: greenfield SaaS-style product engineering, and any workflow that depends on a specific agent's custom behaviors outside the Kiro CLI. And it's an honest trade-off that most enterprises are not operationally ready to manage a swarm of autonomous agents. Parallel agents multiply model calls, compute, CI activity, API usage, and tool access — not just token spend. Before you let persistent agents loose on a source repo, you need real policy around least-privilege access, human overrides, memory retention, code provenance, and audit trails.

Is it worth adopting?

Kiro Crew is free, open source, and self-hostable, which dramatically lowers the barrier to evaluating it. You pay only for the agents and tools you connect to it. For a team already running Kiro's IDE, adoption is expected to be smooth — it reuses existing .kiro configurations, steering files, skills, and custom agents without extra setup.

For everyone else, treat it as a pilot, not a drop-in replacement. Stand it up in a dev environment, wire it to one real workflow you already run, and measure two things: whether it actually reduces human babysitting, and whether the governance and audit features hold up under real least-privilege pressure. The 39,000-engineer internal adoption is genuinely encouraging. The proprietary-CLI caveat on a supposedly open platform is the honest reason to stay skeptical until you've watched it drive your toolchain, not AWS's.

The bigger takeaway is direction: the market is consolidating around the idea that orchestration and governance — not raw model quality — are the real bottleneck in agentic coding. AWS now has an entry in that race, and because it's open source and championed by a hyperscaler, it's going to set the bar for everyone else. In this space, that alone makes it worth watching.

If you already run coding agents in production and you're thinking about moving from "agents as assistants" to "agents as a team," Kiro Crew is one of the most credible open-source starting points available right now.

DEV Community: TerminalBlog

Codex Just Made GPT-6 Astra Its Default — and Nobody Is Talking About It

1. GPT-6 Astra is the default now

2. Experimental worktrees: dangerous experiments without the danger

3. Windows finally gets a first-class background server

4. The agents dashboard: multi-task workflows became usable

5. Vim mode grew up

6. Safety got quieter and stricter

7. Plugins became manageable, MCP got polished

What to actually do

What the wave says

Related articles

OpenHands Just Added the Git Sync Button Everyone Begged For — And Made Kimi K3 Free by Default

The Git Sync Page: Automation That Feels Obvious in Retrospect

Kimi K3 as Default Canvas Model: Free Tier Just Got Serious

LLM Pre-Flight Validation: Catch Config Errors Before They Burn Sessions

Structured Error Outcomes in Canvas: See the Failure, Not Just the Stack Trace

Under the Hood: Fixes That Prevent Silent Session Death

Migration Notes: What Breaks, What Doesn't

Why This Release Signals Maturity

Should You Upgrade?

The Bigger Picture: Open Source Agents Are Catching Up

Quick Start: OpenHands Cloud (2 Minutes)

Quick Start: Self-Hosted (Docker)

TL;DR

What the 1.15–1.17 wave added

Related articles

- Context Engineering for Coding Agents: How to Make Every Token Count

Best Coding Agents 2026 — Decision Guide

Related articles

- Coding agents vs GitHub Copilot: autocomplete is not an agent

Start with the job, not the brand

Step 1 — Check real adoption (not vibes)

What the numbers actually tell you

Step 2 — Feature fit

Feature deep dives

Step 3 — Security posture

Security red flags

Security green flags

Step 4 — Real cost

Cost comparison framework

Step 5 — Head-to-head pages that matter

Per-tool deep dives

This week in coding agents

August–September 2026 cycle

Earlier cycle (July–early August)

The curated comparison library

The meta-debates that change your pick

Recommended default stacks (2026)

Make any agent 10× better

Decision checklist

FAQ

How we update this page

GitHub Copilot CLI Just Made Shared Terminal Sessions Real — Here's Why It Changes Everything

The Headline: Agent Host Protocol (AHP)

Why This Matters for Beginners

Cloud Sessions: Your Agent in a Codespace

The Sessions Tab Got a Complete Redesign

MCP Servers Finally Work Reliably

Model & Plugin Updates

Quality-of-Life Fixes You'll Notice Daily

How to Update

What This Means for Your Workflow

The Bottom Line

Related Reading

Related articles

- Claude Code: Skills vs Subagents vs MCP — The 2026 Decision Guide

OpenAI Just Slashed GPT-5.6 Prices 80% — Coding Agents Got Way Cheaper

The Numbers That Matter

Why This Breaks the Old Cost Models

Luna at $0.20 / $1.20 is effectively "too cheap to meter" for agent workflows

Terra at $2.00 / $12.00 is the new "default production model" for coding agents

Sol Fast mode (2.5× speed, 2× price) changes the latency/cost tradeoff

What This Means for Your Agent Stack

If you use Cursor (ChatGPT Work / Codex)

If you use Codex CLI / ChatGPT Codex

If you use Claude Code / Anthropic API

If you use OpenCode / OpenRouter / BYOK setups

If you self-host or use local models

The New Agent Routing Logic (Steal This)

2. `hermes peer` — bots can DM each other

`--approve-for-me`: let the agent approve routine reviews