---
title: 'In the News: September 21, 2026 (Extra)'
description: 'Foremerge makes parallel coding agents declare what they will change before they change it, and gates acceptance on a check it runs itself.'
canonical_url: 'https://darkfactory.dev/news/2026-09-21-extra'
markdown_url: 'https://darkfactory.dev/news/2026-09-21-extra.md'
collection: news
date_published: '2026-09-21T14:40:00-04:00'
date_modified: '2026-09-21T14:40:00-04:00'
---

# In the News: September 21, 2026 (Extra)


Two agents can each do reasonable work in separate worktrees and still undo each
other, because Git compares text and not intent. A project published this morning
attacks that directly, by making agents say what they are about to change before
they change it. Also this cycle: an outside measurement of Grok 4.7, whose numbers
until now were all SpaceXAI's.

## 1. Foremerge asks coding agents to declare intent before they write code

**[Foremerge](https://github.com/naw103/foremerge)** · naw103, GPTree · Show HN, September 21, 2026

Foremerge is a coordination layer that sits above Git: one Rust binary, Apache-2.0,
version 0.5.0, with its shared state in a SQLite file inside the repository's Git
common directory. Before editing, each agent publishes an intent and the semantic
scopes it will touch, plus the operation it intends on each one. Scopes come in
twelve kinds, from `symbol` and `api` through `schema`, `migration` and `contract`.
When one agent declares `symbol:PaymentService=replace` and another declares
`symbol:PaymentService=extend`, the second publish returns a HIGH
`destructive_vs_additive` finding before either has written a line. Detection is
deterministic: in the project's own words, "it never asks a model to judge
conflicts, so the same inputs always produce the same answer."

The acceptance gate is the more interesting half. "Acceptance is verification-gated:
Foremerge runs the check itself rather than taking an agent's word for it," the
documentation says, and agent-reported test results are "provenance only. They do
not satisfy acceptance." Where a repository has nothing worth checking, work is
"recorded as UNVERIFIED with the reason, so the audit trail never implies a check
ran when none did." Claims on a scope are advisory leases rather than locks, with
a stated reason: "a single crashed agent would then stall the whole fleet."

The project is candid about what it has not shown. Its own limitations section
calls conflict detection "deterministic and explainable, but heuristic," able to
"miss synonymous concepts and warn on compatible work," and says there is a
benchmark plan but "no published coordinated-vs-uncoordinated performance results
yet." That sits awkwardly beside the Show HN post, which claims the author has
"tested this up to 98 parallel agents all working on the same repo with zero
conflicts." The more careful figure is in the same post: a replay of 76 real
intents, one conflict flagged, and a disclosed blind spot where one agent claimed
a scope by class name and another claimed it by an internal method.

**Why it matters:** Most fleet tooling so far has given agents more isolation.
This gives them a shared declaration and then refuses to take their word for
whether the work passed. If you are running more than one agent on one repository,
the question it raises is answerable today: what would your agents have to declare
for a collision to be visible before the code exists?

## 2. Grok 4.7 gets a measurement its vendor did not run

**[Grok 4.7 Intelligence, Performance and Price Analysis](https://artificialanalysis.ai/models/grok-4-7)** · Artificial Analysis · September 2026

Artificial Analysis has published its own evaluation of Grok 4.7, scoring the
reasoning version at 46 on its Intelligence Index and ranking it 16th of the 655
models it tracks. Version 4.3.2 of that index bundles ten evaluations, including
Terminal-Bench 4.0 for agentic coding and terminal use. The number practitioners
should look at twice is not the rank. Running the index took Grok 4.7 240 million
output tokens against a median of 92 million across comparable models, which
Artificial Analysis reports as a verbosity rank of 140th out of 655. The model
carries a 500k token context window.

**Why it matters:** Grok 4.7 arrived with every figure supplied by SpaceXAI. This
is the first measurement of it we have seen that did not come from the vendor. It
also moves the cost question off the price card: at about 2.6 times the median
token spend per task, what a harness pays for this model is set by how much it
writes, not by the per-token rate.

---

## Thread watch

_Discussions gathering force. No primary read yet, so these are reported as
discussions, not as findings._

- **[Fable 5: Median thinking declined in August](https://news.ycombinator.com/item?id=49789224)** ·
  Hacker News · 167 points and 98 comments at 2 hours 19 minutes after posting,
  observed 18:33 UTC on September 21. We have not read the underlying post, so
  nothing here is a report of what it found. The thread itself is worth watching
  because it keeps splitting on method rather than on the conclusion. One commenter,
  CamperBob2, asks the question the rest of the argument depends on: "How do you
  measure thinking tokens? They don't send those back to the client." Others point
  at third-party trackers and at the difference between a vendor saying it does not
  intentionally reduce quality and a vendor saying nothing changed.