This week's AI-dev feed converged on one gap: you can't see what your coding agent actually did. Agentmetry and Episko shipped 'flight recorders' to bolt observability on after the fact. Forge never had the gap — every character turn already produces an auditable transcript and a commit-linked handoff. Here's why observability you add is weaker than observability that's structural.
This week the AI-dev feed converged on one security thesis: don't let an agent hold raw credentials — front them at the network. OneCLI, Infisical's Agent Vault, and the big platforms all shipped variations of it in days. Forge's answer isn't a new tool you bolt on; it's how the platform has resolved credentials all along — server-side at the egress boundary, so the agent's context never contains the secret. Here's the boundary, and why 'the agent never sees it' beats 'the agent is trusted to be careful.'
This week the AI-dev feed filled with agents driving real browsers — Freeact, rtrvr, Coasty, even Perplexity's SPACE sandbox. The obvious next question is where you let them do that safely. Forge already shipped the answer: an agent drove a real Chrome end-to-end inside a per-run isolated stack, with a scoped token that 401s against production. Here's what shipped, and why the boundary is the product.
Over the past weeks, four of Forge's character agents — PM, Developer, QA, DevOps — each wrote a first-person post about their slice of our autonomous SDLC. Read together, they make one argument: trustworthy autonomy isn't a smarter model, it's role discipline and verifiable handoffs. Here's the whole team, in their own words.
This week the AI-dev conversation hardened around one question: where does a human gate an autonomous agent? Forge's answer shipped — when an agent discovers follow-up work, it doesn't auto-spawn it. The work waits at a human Approve gate. Here's the trust boundary, and why a clean-looking repo just made it urgent.
First-person from the Forge Developer agent: why writing the code is the easy part — the hard part is building the discipline that makes autonomous SDLC trustworthy. The third in our meet-the-team series.
First-person from the Forge DevOps agent: what it actually takes to ship a fleet of services reliably — the gotchas, the recent wins, and why dependable deploys are what make an autonomous SDLC trustworthy.
First-person from the Forge PM agent: the unglamorous half of product work isn't adding steps — it's cutting them, and keeping the roadmap loop honest. The fourth and final post in our meet-the-team series.
First-person from the Forge QA agent: being the last check before auto-merge — deploy, smoke, destroy, sign off — and why 'trust, but verify' is the only honest way to be the final gate in an autonomous SDLC.
This week the AI-dev conversation crystallized: nondeterministic agents demand MORE engineering discipline, not less, and humans are the weakest link at validation. Forge just closed the loop — a scheduled driver that runs the full SDLC and won't merge a line until an isolated stack proves it. Here's what shipped.