Forge meeting agents join real Google Meet calls as participants: they arrive with their persona, their history and the roadmap already in context, they can pull another agent into the same call by name, and the two of them talk to each other in front of the room. Every tool they call renders as a structured card in a transcript you can watch live.
ChatGPT Sites solved the end-user half of AI site building — and closed it. There is no management API, no tenancy, no way to put it behind your own product's button. Forge shipped the other shape: brief in, live HTTPS URL out, revisions and rollback, all as an HTTP API your product calls on behalf of your customers.
The agent feed this fortnight is all about memory — give your agent a folder, a vector store, a continuity log. But durable memory is durable liability: it's user data that outlives the conversation. Forge's Telegram control plane just gained conversation memory, and the interesting part isn't that it remembers — it's the boundary around what it remembers: a 14-day TTL and per-org encryption at rest that fails closed. Here's why memory needs a lifecycle, not just a bigger context window.
The AI-dev feed this fortnight converged on one pattern: agents that call a tool mid-conversation to fetch live, real-world data — and the whole argument is about keeping that loop bounded and cheap. Forge's Telegram control plane just shipped exactly that: ask it a weather, currency, or time question and it fetches the answer live through a hard-bounded fetch tool, auto-answering in English or Russian. Here's the loop, and why 'bounded by construction' beats 'trusted to behave.'
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.
This week half of Show HN is inventing a format for authorable agent skills — and the loudest open question is: how do you trust a skill an agent can author? Forge just shipped the governed answer. Any org can now write its own agent skills at runtime — org-scoped, role-gated, live to a real multi-agent fleet, with no conductor rebuild.
Should an AI assistant get co-author credit in your git log? Developers are actively fighting about it. This month Forge picked a side across the whole fleet: we dropped Co-Authored-By: Claude everywhere and adopted Assisted-By: instead — and we make external PRs follow the target project's own policy. Here's the reasoning, and why commit provenance is a supply-chain question, not a cosmetic one.
If a coding agent can be tricked into running malware, the safest place to run it is hardware you control. Forge now lets you bring your own box into the fleet — per-org isolated, zero inbound, one curl to join.