sprawling v0.0.5-Pre-alpha-260912

⚠️ Please do not download this release. It is published to test the release
pipeline, not to be used. Treat anything it produces as scaffolding.

⚠️ 请不要下载这一版。 这个版本是为了测试发布流程而发出来的，不是给人用的，它产出
的一切都请当作脚手架看待。

📋 What changed / 本版改动：CHANGELOG.md

sprawling v0.0.4-Pre-alpha-260911

v0.0.4 — pre-alpha

Please do not download this release

It is published to test the release pipeline, not to be used. This tag
exists so that a machine can build the archives, sign nothing, publish them, and
let me check that the whole path from a green tree to a downloadable file still
works. Treat anything it produces as scaffolding.

If you want to look at the project, read the source. If you want to run
something, wait for a release that does not carry this notice.

请不要下载这一版

这个版本是为了测试发布流程而发出来的，不是给人用的。 打这个标签，是为了让机器把
归档构建出来、发布出去，好让我确认从一棵绿树到一个可下载文件的整条路还走得通。它产出
的一切都请当作脚手架看待。

想了解这个项目，请读源码；想跑起来用，请等一个不带这条提示的版本。

---

Everything below is this release's entry in
CHANGELOG.md, unchanged.

---

v0.0.4-Pre-alpha-260911

The shape of the work was: give the city a planner to talk to, replace the
client with one anybody can rewrite, and make a resident able to finish a piece
of work on its own — read a file in parts, search for a symbol, run the build,
hand over to its successor when the window runs out.

The city has a city hall

• Every city is raised with one building already standing: hall, which holds
  no project of its own. The Mayor plans and writes Markdown; the clerk answers
  the approvals a person delegated, in the same three parts a Gate uses. The
  Mayor has no exec, no delegate and no workshop, because a planner that
  can run code stops reading the buildings' evidence and starts producing its
  own.
• WriteDomain::Documents lets a resident write the city's Markdown and
  nothing else; the reserved subtree and every Roadmap.md stay out of reach,
  so a planner cannot rewrite the plan it is being measured against.
• The city tool raises, adopts and lists buildings, so a plan can grow the
  city it describes.

The client is TypeScript, and the WebAssembly one is gone

• client/ is Solid and Effect, built by bun, and the page it produces is
  embedded in the binary at build time. The first screen is a conversation with
  the Mayor rather than a dashboard.
• The city is drawn as a map; a building opens as a file tree; a run reads
  through four lenses — rounds, changes, evidence, cost — each answered by the
  city rather than folded in the browser.
• A building's git history is a page: commits, the files one commit changed,
  the patch itself, and the session that wrote it as a link into that room's
  conversation. Lines matching a credential shape report their line number
  rather than their bytes.
• Voice input where a transcription endpoint is registered: the recording goes
  to POST /transcribe and the text lands in the composer rather than being
  sent, because a machine that mishears must be correctable before it spends a
  run.
• The wasm client and its 112 files left the tree. One client, one build
  command, one bundle: 108.0 KiB.

A resident can finish a piece of work

• read takes an offset and a limit, and a new search tool finds a symbol
  without a shell. Both are capped at 64 KiB cut on a line boundary, so a
  generated file cannot spend a window; the envelope says which line to resume
  from and that answer is the only one.
• exec inherits exactly the environment variables a building declares, so a
  resident can run this repository's own toolchain. A command that outlives a
  ten-second window returns a handle and keeps running; halt terminates what
  it started, including delegated runs.
• runtime::sieve compresses a tool result without a model: the same seed and
  the same filter table replay a byte-identical window, and every compressed
  result carries the way back to the original.
• A frozen run exports the messages the model actually saw beside its room, and
  a successor inherits the same depth and the same tools. Provenance records the
  predecessor, so a lineage reads back as a chain.
• Context is reported at 25% and 65% of the window, once each, off the token
  count the provider returns rather than an estimate of the bytes.
• The spending ceiling is deleted. Nothing here prices a piece of work before it
  runs; the brake is halt, and the cost page still reports what was spent.
• A provider that runs out either freezes the run or moves to a named
  endpoint — never a silent substitution, because that is the one decision a
  default must not make.

Concurrency, and who owns the Ledger

• One thread owns the Ledger and the books; a pool of driving threads owns
  nothing but the drive in flight. A building working towards a goal takes its
  whole ready set at once, four runs at a time, each in a lane of its own. Runs
  are driven in parallel and accounted for in series.
• A wave fence no longer moves HEAD: checkpoints are written under
  refs/sprawling/runs/, so a city's own history does not grow a commit per
  tool wave.
• Every commit the city makes carries who ran it, under which model and effort,
  in which city; sprawling whose <city> <oid> reads it back from the Ledger
  rather than from git.

Sight, and the desktop

• An image is a content block on the wire, translated into both dialects, with
  the bytes fetched from the content store at the last moment.
• The browser tool drives a real browser over BiDi: open, snapshot, act,
  screenshot, measure, console, viewport, close. A screenshot lands in the
  content store and comes back as evidence.
• sprawling-desktop is a separate MCP server for Windows: windows, snapshot,
  act, screenshot, record, clipboard — each refused on any platform without an
  implementation rather than faked. A building reaches the desktop only by
  saying so, and the allowlist lands where no resident can widen it.

Doctor, platforms, and the first run

• sprawling doctor is the single authority on what this machine has. The first
  screen shows its answer, each item a state rather than a sentence, and a city
  that has never been probed says so instead of guessing.
• A static x86_64-unknown-linux-musl archive was built for the release matrix
  and is not in this release. Its first real build found the reason: the
  Linux credential store is D-Bus secret-service, and a static binary cannot
  link one. What that build needs settled is where a Linux install keeps a
  person's API key, which is not a decision a release workflow makes on its way
  past. Windows and macOS archives are what this tag carries, as before.
  Everything else the row needs is built and stays — just package takes a
  triple, the archive name carries it, and install.sh knows that name.
• A flake derives its toolchain from rust-toolchain.toml rather than
  restating it.
• Every CI job declares how long it may take, so "fifteen minutes" is a
  checkable promise rather than a wish.

Numbers

• 1,415 tests across the workspace, 79 more in the desktop server, 29 in the
  client. A full run takes 83 s on a sixteen-core laptop with a warm cache.
• The wire is at version 21 with 24 queries and 24 commands; the client's types
  are generated from it and a gate refuses a tree where the two disagree.
• The binary is 9.47 MiB on Windows; the bill of materials lists 286 packages.

sprawling v0.0.3-Pre-alpha-260903

v0.0.3 — pre-alpha

中文原文在后半篇。

From this release on, every tag carries its date: v0.0.3-Pre-alpha-260903.
A pre-alpha version number says almost nothing about how old the tree is, and
that is the thing you most need to know before downloading one. The two earlier
tags have been renamed the same way, and there is a
CHANGELOG.md now, which should have existed from
the first day. What changed in this release, card by card, is in there.

---

This release went into the back end and removed a number of design problems.
Most of what was meant to exist now does, and the gap between this and what I
first sketched is no longer large. If features arrive from here on, it will
mostly be because I found something interesting, not because I was filling a
hole I left.

On small and good, small is now holding up. Set it against the other harnesses
that advertise being small — fx, say — and
against the ones that advertise session RAM — jcode —
and it does not come off worse, once the WebUI is taken out. The WebUI is the
subject of the next section.

The measurements behind that

Every reading below is from this release's own build on one machine
(windows-x86_64, i5-1340P), taken with the instrument this repository gates
itself with.

What	Reading
The binary you download, with the whole WebUI client inside it	8.88 MiB
The client it carries, gzipped	657.7 KiB
The binary without the client	≈ 8.25 MiB
A city serving — ledger open, socket listening, no model attached	7.97 MB working set (2.37 MB private)
Process start, warm	58–63 ms

From the two projects' own READMEs: fx states a 7.8 MiB binary; jcode states
27.8 MB PSS for one active session with local embedding off, and 167.1 MB
with it on.

Be careful what that comparison is. jcode's number is PSS, a Linux counter,
measured with a session actively running; mine is WorkingSet64, a Windows
counter, measured on a city that is serving and idle. Different counters,
different operating systems, different load — and I have not run either project
on the other's platform. Read the table as this is the weight class, not as a
benchmark. The one conclusion it does support is that carrying a browser
interface did not cost me the thing I said I would not give up.

---

The front-end problem is not solved, so the issue stays open — I will keep
fixing the WebUI and close it when I think it is worth using daily.

And I have been thinking: a front end is essentially a theme, and it ought to be
replaceable. I am exploring a direction where TUI, GUI and WebUI are a free
choice and open to extension. Everyone has their own taste and their own habits
of work, and models keep getting stronger, so of course people can run a front
end styled however they like — not a colour swap or a background image, but the
interaction logic itself designed around what they prefer. (A well-designed front
end still matters. A carefully designed one beats a good-looking, interesting one
thrown together in an afternoon by a wide margin on productivity and usability.)
Perhaps a UI market later on: install the core, open the market, pick one you
like. Installation gets faster that way, and to some extent it does not even need
to be a market of code — it could be a market of prompts. An agent can easily
learn what the back end offers and what shape the interface is; all the user has
to submit is their own taste (Stardew Valley, say, or a cat house) and a complete
front end is generated from that.

I am pushing hard on splitting files. What we have now is plainly over budget
for a human reader and for an LLM alike, and pressing everything down into a few
hundred lines is the better option.

As for remote control, multi-device collaboration, and agents talking across a
network: I am not trying to make this a universal platform. A single harness
should carry a deliberately limited amount. So I am building
kusanagi as the answer to that — it is the
more promising project of the two — and I hope it brings some surprises.

For a while there probably will not be any large back-end moves; stability
matters. The next release is again mostly about how to fix the experience and
reduce bugs, and I would like to leave pre-release status as soon as possible.
Along with that, the documentation and the interface text: it is all
agent-written at the moment, some of it long-winded and some of it abstract, and
I will replace it with human-written text wherever I can.

Testing so far is on two browsers, headless Edge and Zen; there will probably
need to be more. The other serious problem is that I have no macOS device, so I
have no way to actually test how it behaves there.

---

Getting it running

Download the archive for your system, unpack it, and run the launcher inside.
Nothing is installed and nothing outside that folder is written to.

System	Archive	What to run
Windows	sprawling-0.0.3-windows-x86_64.zip	double-click start.cmd
macOS	sprawling-0.0.3-macos-aarch64.zip	./start.sh in a terminal

A console window opens and stays open — that window is the city. Your browser
opens at http://127.0.0.1:8787. Ctrl-C in the window stops the city.

These binaries are not code-signed. Windows says "Windows protected your
PC": choose More info → Run anyway. macOS refuses the first launch: open it
once from Finder's right-click menu.

You need a model to call before it can do anything — an API key for a
provider speaking the OpenAI or Anthropic dialect, or a subscription login. This
program schedules agents and records what they do; it does not think by itself.

---

v0.0.3 — pre-alpha（中文）

从这一版起，每个 tag 都带上年月日：v0.0.3-Pre-alpha-260903。一个 pre-alpha 的
版本号几乎说不出这棵树有多旧，而下载之前最该知道的就是这件事。之前两个 tag 已按同样的
规则改名，另外现在有 CHANGELOG.md 了——这本该从第一天
就有。这一版逐张卡改了什么，写在那里面。

---

这个版本优化了后端减少了一些设计问题，应该实现的功能也推进得差不多了，同最初设想的
差距已经没有很多，如果未来有功能新增，大抵是发现了新的有意思的功能。当前在小而美上
已经表现不错，对比一下其他宣传体积小的 harness（例如：https://github.com/vercel-labs/fx），
Session RAM 的 harness（例如：https://github.com/1jehuang/jcode）也不会差了（如果
删去 WebUI 的话，至于 WebUI 的问题下面会讨论）。

上面那句话背后的读数

下面每一条都出自这一版自己的构建、同一台机器（windows-x86_64，i5-1340P），用的是这个
仓库给自己设门时用的同一件量具。

量的是什么	读数
你下载的那个二进制，整个 WebUI 客户端就装在里面	8.88 MiB
它带着的那份客户端，gzip 后	657.7 KiB
去掉客户端之后的二进制	≈ 8.25 MiB
一座正在服务的城——账本已开、socket 在听、没接模型	7.97 MB 工作集（私有 2.37 MB）
进程启动，热态	58–63 ms

取自那两个项目 README 里自己写的数：fx 是 7.8 MiB 二进制；jcode 是关掉本地嵌入、
一条活跃会话时 27.8 MB PSS，开着则是 167.1 MB。

这个对比要小心它不是什么。 jcode 那个数是 PSS，Linux 的计数器，量的是一条会话真的
在跑；我这个是 WorkingSet64，Windows 的计数器，量的是一座在服务但空闲的城。不同计数
器、不同操作系统、不同负载，而且我没有在对方的平台上跑过对方的项目。这张表读作「大致
在这个量级」，不要读成一次基准测试。它唯一支持的结论是：带一个浏览器界面，并没有让我
付掉那件我说过不会放弃的东西。

---

但目前前端问题还没有解决，所以 Issue 依然挂着没关，我会修正 WebUI 问题直到我认为值得
日用再关闭。而且我在想，前端本质上就是主题，应该是可以替换的，正在探索往 TUI／GUI／
WebUI 自由选择和开放拓展的方向发展，每个人都有自己的审美，也有习惯的工作方式，模型
越来越强大，大家当然完全可以使用自己定制风格的前端（当然设计优秀的前端仍有意义，毕竟
经过精细设计的前端在生产力和可用性上会比随手做出来好看有意思的强上很多），不是换色／
背景图，而是完全基于自己的喜好设计交互逻辑。也许未来可以设计一个 UI 市场，下载本体后
直接打开市场选一个喜欢的安装。这样的好处是安装会变得更快，而且一定程度上来说甚至都
不需要做一个基于代码的市场，可以是一个基于 Prompt 的市场，Agent 可以轻松的了解后端有
哪些功能，接口的形状什么样，只需要用户提交一个自己的审美偏好（例如用星露谷小镇或者
猫窝作为主题）就可以生成一整个完整的前端。

我在努力推进拆分文件的事情，目前很明显对于人还是 LLM 都完全超额了，代码全部压入几百行
是更优选。

至于远控与多设备协作，远程多 Agent 交流方面，我没有想着把它做成一个万能平台，单一
Harness 应该承载的内容必须精简有限，所以我正在开发 https://github.com/2youg1/kusanagi
作为一个解决方案（这是个更有潜力的项目），希望它可以带来一些新的惊喜。

接下来一时半会大概不会有后端大动作（稳定很重要），下个版本依然是思考怎么解决体验问题
和减少 BUG 为主，希望尽快脱离 pre-release 状态。以及各种文档和 UI 文字的优化，目前都是
Agent 创作，有些表述拖沓和抽象问题，会尽可能换成人工创作版本。

目前的测试都基于无头 edge 和 Zen 两个浏览器，未来可能要更多测试，另外一边严重的问题是
我没有 MacOS 设备我没办法实际测试其表现。

---

怎么跑起来

下载对应系统的归档，解压，运行里面的启动器。 不安装任何东西，也不往那个文件夹之外
写任何东西。

系统	归档	运行什么
Windows	sprawling-0.0.3-windows-x86_64.zip	双击 start.cmd
macOS	sprawling-0.0.3-macos-aarch64.zip	终端里 ./start.sh

会打开一个控制台窗口并一直开着——那个窗口就是城。浏览器会打开
http://127.0.0.1:8787。在那个窗口里 Ctrl-C 停城。

这些二进制没有代码签名。 Windows 会说「Windows 已保护你的电脑」：选更多信息 →
仍要运行。macOS 第一次会拒绝：在访达里右键打开一次即可。

它能干活之前你需要一个可调用的模型——一个说 OpenAI 或 Anthropic 线格式的服务商
API key，或者一个订阅登录。这个程序调度 Agent 并记录它们做了什么；它自己不思考。

sprawling v0.0.2-Pre-alpha-260827

v0.0.2 — pre-alpha

中文版在后半篇。

This replaces the v0.0.2 I put out this morning. Same version number on purpose: nothing here changes what the program does, only whether you can watch it do it. I would rather correct a release than let a number tell you the front end was finished.

Everything the v0.0.1 notes said about being pre-alpha still holds, and I will not repeat all of it: this is my learning project, and I would rather have your criticism than your patience.

Last time I wrote that the front end was bad and that I agreed with you about it. I have spent this release on that, and I want to be exact about what changed, because "improved the UI" is the kind of sentence that means nothing.

The interface was hiding the product

That is the honest summary. Everything sprawling does that other harnesses do not, it does inside a single turn — a refusal that tells you what it refused and how to get past it, a checkpoint fence, a write stopped at the edge of its domain, a compaction that says what it dropped. The client folded three of fifty-eight kinds of event and threw the rest away, so all of that reached your screen as the same grey line as a successful file read. You could not see the thing I built.

A turn now tells you what happened in it. What the model said, what the turn cost in tokens and in dollars, what each tool actually answered, and what a door refused along with the way round it. What stings is that none of this was new data — the payload had been carrying the message, the usage, the stop reason and the billed amount the whole time, and the fold simply never read them. I had also written in a note to myself that token counts were "not on the wire". They were. I was wrong, and I have said so in the record.

Opening yesterday's session showed you an empty page. There was one history query and it did not take a session, so four sessions running at once split a single slice of five hundred records between them, and anything older than that slice was not in it at all. You can now ask for one session. The tab still holds a bounded amount of history — it has to, or a tab left open all night dies — but it now gives way in the session you are not reading rather than in the one you are.

Every tool wave has been fenced by a real git commit since early on, and nothing could read one back. The write side was git-native and the read side did not exist. A session now lists the files it changed with + and − counts, taken from git between two real checkpoints. One thing I am quietly pleased about: because the fence is the write domain, that list cannot contain a file an agent merely read — which is exactly the complaint people have about the same feature elsewhere, and here it comes free from a decision made for another reason entirely.

Dragging a file onto the box where you write work did nothing — and worse, the browser was quietly answering the gesture instead. A plain text input accepts a dropped selection all by itself, so a drag went in raw and every rule I had written about what a drop means never ran. A drop now reaches the composer and a running session's own box; it fills the box and never presses the button, because a gesture that spent money would be one you could not take back. And a drop target now lights up while you are dragging over it, which the old hover rule could never do — a browser suppresses pointer events for the whole of a drag, so that outline was invisible at exactly the moment you needed it.

A building's own pages were one flat wall of text. Headings, lists, links, inline code and fenced blocks now come apart. They come apart by lightness, by weight, by slant — and by no colour at all. This interface has exactly two colours: one means "something is happening here", the other means "a person is needed here". A syntax-coloured document would have spent both of them on something that means neither. Once you notice that constraint it stops feeling like a constraint.

All of it cost 35 KB in the client, weighed one change at a time. The budget is 2 MB and this uses under a third of it.

Three features that existed and could not be reached

These are from the first cut of v0.0.2 and still describe it. Each was found the same way: by asking who calls a thing, and finding nobody.

A city could not accept a browser from another machine. Exposing the WebUI beyond loopback is a four-link chain and three links were cut. PairingToken::mint had no caller — a type whose own documentation says it hands back a code "to show to a person once" had never shown one. The page built its link without the token, and the socket URL kept only the host, dropping the query string on the way. So a city bound to 0.0.0.0 with SPRAWLING_PAIRING_TOKEN set demanded a token from every peer while its own client never sent one: the server refused its own WebUI, in the exact configuration the token exists to enable.

The console could not answer a question. It replied to every query with the text of a sprawling call command — asking someone already standing inside a city to open a second terminal and interrogate it from outside. The function that could answer had been built one line above and handed only to the socket.

exec's refusal named an install nobody could perform. The refusal reads "use the program arm, or install a build with the wasm feature", and that build did not exist. It exists now, behind --features sandbox. Read the last section before you expect it in this archive.

Four failures that were reported as something else

A run under review put its decisions on the building's shelf. A building under review lends every run its own tree so that nothing it writes belongs to the building until somebody checks it. The archive drain wrote outside that tree.

A file that would not open looked like a file somebody wrote badly. An unreadable plan was flattened to an empty string and then reported as a plan somebody had changed; an unreadable handoff meant "there was no handoff". Both now say what actually happened — and that difference matters most where it is least visible.

A change could outrun its own record. A line the history refused is now a change the city never made, and a merge waits for the line that announces it.

A ceiling could be lost twice. Work handed to another resident now runs under the ceiling that sent it, and answering an approval resumes the same work instead of restarting it under a default.

The same ask arriving twice is one piece of work. Retries and duplicate frames now settle against the idempotency key the command already carried, instead of one minted from content.

Under the surface

The dispatch path went from a single 1069-line function to 158 across named phases. A machine gate now fails the build on any production function past 200 lines, and nothing was exempted to make it pass. There are 1,206 tests and thirteen gates, and a change is not finished here until all of them are green.

---

Getting it running

Download the archive for your system, unpack it, and run the launcher inside. Nothing is installed and nothing outside that folder is written to.

System	Archive	What to run
Windows	sprawling-0.0.2-windows-x86_64.zip	double-click start.cmd
macOS	sprawling-0.0.2-macos-aarch64.zip	./start.sh in a terminal

A console window opens and stays open — that window is the city. Your browser opens at http://127.0.0.1:8787. Ctrl-C in the window stops the city.

These binaries are not code-signed. Windows will say "Windows protected your PC": choose More info → Run anyway. macOS will refuse the first run: open it once from Finder's right-click menu, or clear the quarantine attribute.

Before it can do anything you need a model to call — an API key for a provider speaking the OpenAI or Anthropic dialect, or a subscription login. This program schedules agents and records what they do; it does not think by itself.

QUICKSTART.md inside the archive walks the first ten minutes. Every archive also carries sbom.cdx.json, the full bill of materials for the binary beside it.

Please know this before you start

• This archive does not carry the execution engine. sandbox is off by default because wasmtime is a large binary and I did not reopen that trade here. Anything routed through the sandbox still answers this build carries no execution engine; the arm that runs a program on your machine works as before. Build it yourself with cargo build --release -p sprawling --features sandbox.

• First run has two steps that are easy to miss: after attaching a provider you must pick a model for main and for digest, or every dispatch is refused with no model is chosen for this tag.

• Reaching a city from another machine needs SPRAWLING_PAIRING_TOKEN. Binding to a non-loopback address without one is refused on purpose. With one set, the console prints a URL carrying the key — open that URL rather than typing one by hand, or the server will refuse you the way it used to refuse itself.

For anything else, email me. I check often.

---

---

v0.0.2 — pre-alpha（中文）

这一版覆盖了我今天上午发的 v0.0.2。 版本号是故意不动的:这里没有一处改变程序做什么,只改变你能不能看见它在做。与其让一个新号码暗示前端做完了,我宁愿把同一个号码重发一次。

v0.0.1 说过的关于 pre-alpha 的话现在仍然成立,我不再重复一遍:这是我的学习项目,比起你的耐心,我更想要你的批评。

上次我写过前端很糟,而且我同意你的看法。这一版我花在这件事上,并且想把改了什么说准确——因为「优化了 UI」这种句子等于什么都没说。

界面一直在挡着这个产品

这是实话。sprawling 与别的 harness 不一样的地方,全部发生在一轮里面——一次说得出拒了什么、怎么绕过去的拒绝;一道检查点栅栏;一次被写域拦下的写入;一次报得出自己丢了什么的压缩。而客户端只折叠了 58 种事件里的 3 种,其余全扔。于是这些东西到你屏幕上,和一次成功的读文件长成同一行灰字。你看不见我造的那个东西。

现在一轮说得出自己发生过什么。 模型说了什么,这一轮花了多少 token、多少钱,每个工具到底回了什么,以及哪道门拒了什么、怎么绕过去。扎心的是这些数据一个都不是新的——载荷里一直带着模型的话、用量、停止原因和账单金额,只是折叠函数从来没读过它们。我甚至在自己的笔记里写过「token 用量线上没有,是我编的」。它有。我记错了,并且已经把这条更正写进记录。

**打开昨天的会话,给你的是一张空白...

sprawling v0.0.1-Pre-alpha-260824

v0.0.1 — pre-alpha

I am sorry for releasing this early. By rights I should have debugged it alone for another week; read this as the impatience that follows a first taste of vibe coding, and accept my apology for the sloppiness.

This is pre-alpha, and until you are ready to work around problems I do not even want to recommend that you download it. The harnesses we all use — the ones with tens or hundreds of thousands of stars — have been debugged and tuned for a long time, which is why they rarely go wrong under your hands. You only find out how many details are involved, and how much work a merely normal experience costs, after building a harness yourself. The best tool is the one that lets you concentrate on the work instead of on the tool: the one with the least presence, that becomes an extension of the hand, that helps you make something worth making. sprawling has a long way to go before it is that. It is my learning project, and what I want from it is as much experience — and as much criticism — as I can get.

The front end is bad, and I agree with you about it. Once I have thought it through I will do what I can to get it right. Future updates will keep trying to make this harness small and good; so far only small is true, and I would rather not buy good by giving up small.

In six months sprawling may matter less. More and more frontier labs are post-training only against their own harnesses, so the SOTA experience they advertise arrives locked to one ecosystem — open source or not. RefRain, which a friend and I are pushing along slowly, exists so that you can keep those official harnesses and still own your editing experience. I will put real effort into it.

Almost every sentence here still carries a Claudish accent. I will replace it with better phrasing as chances come, or have the models rewrite all of it once they learn to speak like people.

The thing nobody else does, as far as I could find

Agents here talk to other running agents freely, and no budget rations the conversation. There are good reasons nobody does this, and you can probably name several disasters off the top of your head. My bet is that if models keep getting better at conversation and coordination — without the churn and the spinning-in-place — this may turn out to be worth more as engineering than as a social simulator. It has one extra benefit either way: agents can talk at high frequency, which makes the whole thing feel like a management sim.

Try it with a model trained for multi-agent work — Claude-Opus-5, GPT-5.6-Sol — and it will go better than with one that was not.

And I have a hunch. There are already agents streaming Slay the Spire 2 runs. So: could four agents take four different roles and clear it as a team? How would they coordinate? What would they do after a loss — hold a post-mortem? Convene a tribunal? That is genuinely fascinating, and it is the direction sprawling is designed for. I hope the community builds toward it.

For anything else, email me. I check often.

---

V0.0.1(pre-alpha)发布说明：
很抱歉过早发布了这个项目，理论上我应该再自己调试一个星期再发布，可以理解成接触Vibe Coding之后出现的急功近利，为这种毛躁诚挚道歉。考虑到这依然是pre-alpha版本的项目，因而在你准备好解决一些问题之前，我甚至不敢推荐你下载体验它。现在我们使用的那些万/十万star的Harness都经过了长期的调试和优化，因而使用起来不太可能会有什么问题，只有当自己做过Harness之后才会明白这里会有多少细节，得做出多少努力才会获得一个正常体验。最好的工具是那些可以让你专注于工作而不用为工具而分心，一个最没有存在感和人手结合为一体，那些可以辅助你创造价值的工具，距离达到这个目标sprawling还有很久的路要走，这是我的学习项目，我希望从中获得尽可能多的经验同时接受各种批评。
前端表现很糟糕这点我完全赞同，我想清楚之后会尽可能努力将其调试正常，同时未来的更新我也会尽可能确保这个Harness坚持“小而美”，目前只做到小，希望做到美不要牺牲小。
再过半年可能sprawling的意义会不断下降，越来越多的前沿实验室开始只针对自家的Harness做后训练，这就导致当你想要获得它们宣传的SOTA体验时，就算这个Harness本身是开源的，也锁死了你所使用的生态，我正和朋友缓慢推进的RefRain（https://github.com/2youg1/RefRain）是希望你可以保留这些官方Harness而专注于编辑体验的一个应用，我也会**尽可能投入精力去优化它**。
目前几乎所有表述都沾上了Claudish，有机会就会在更新中逐步换成更优秀的表达，或者未来模型更会说人话之后让它们全部重写。
我在Muti-agent系统中做了一个没人做过的方案（至少在我有限的调研中）：让agent自由地去和其它运行中的agent交流，而且不设置预算。没人做有充分的道理，我相信你随口就能提出好几个坏处和实践中的灾难情况。但我的想法是如果未来的模型社交-沟通能力不断提升，而且不会有严重的内耗与空转问题时，或许这种方案会展现出比agent社交模拟器更有价值的工程能力。当然，这样的设计的确有一个额外的好处：可以让agent以很高的频率交流，像在玩模拟经营游戏。大家可以用Claude-Opus-5或者GPT-5.6-Sol这种特殊训练过多agent协作能力的模型来测试，会比没有训练过的模型有更好的效果。以及我的确有一个猜想，现在已经有了各种Agent直播玩杀戮尖塔2的方案，那么有办法让4个Agent组队用不同的角色通关杀戮尖塔2吗？它们会如何协作？失败了会怎么复盘？复盘会不会开庭？真是太有意思了！sprawling就是往这个方向设计的，希望能有社区方案支持这一切！
所有其他问题请邮箱联系我，我会经常检查。

---

What this release actually contains

Two capabilities landed just before it was cut, both verified end to end rather than by construction.

Residents can find each other. A run asks neighbours and gets every address it can reach inside its building, each carrying the line that resident's own URBANITE.md offers about what to bring them; empty rooms are listed too, because a place to move somebody into is worth knowing about. Detail decays with distance: the rest of the city comes back as building names and nothing more, since reaching another building goes through you. Before this, signal took an address the model had to have been told, and a guessed one opened a queue nobody ever read.

A message reaches its reader whether or not they are working. Speaking to a resident whose run is going slips the message under the door — it lands at the end of their next tool result. Speaking to one who is idle knocks: the city starts a run for them. Both arrive labelled @ and the sender's address, which is also the address that answers, and a resident cannot render as you: only your own entrance can write the user prefix, and that is enforced by a type rather than by discipline. A knock addresses a resident, never a frozen conversation — history is read, not woken.

Two residents in one building negotiated six hours of kiln time to a written agreement over a real provider, each finding the other, arguing a price, and recording what was agreed. That is the evidence behind both claims.

---

Getting it running

Download the archive for your system, unpack it, and run the launcher inside. Nothing is installed and nothing outside that folder is written to.

System	Archive	What to run
Windows	sprawling-*-windows-x86_64.zip	double-click start.cmd
macOS	sprawling-*-macos-aarch64.zip	./start.sh in a terminal

A console window opens and stays open — that window is the city. Your browser opens at http://127.0.0.1:8787. Ctrl-C in the window stops the city.

These binaries are not code-signed. Windows will say "Windows protected your PC": choose More info → Run anyway. macOS will refuse the first run: open it once from Finder's right-click menu, or clear the quarantine attribute.

Before it can do anything you need a model to call — an API key for a provider speaking the OpenAI or Anthropic dialect, or a subscription login. This program schedules agents and records what they do; it does not think by itself.

QUICKSTART.md inside the archive walks the first ten minutes. Every archive also carries sbom.cdx.json, the full bill of materials for the binary beside it.

Known before you start

• Linux archives are not built in this release — the Linux pipeline was ruled out rather than debugged; Windows and macOS are what this release ships.
• exec has three arms and two of them need something installed. The shell arm needs a shell interpreter and the Python arm needs a CPython-WASI component; without them both answer E_TOOL_UNAVAILABLE, while the third arm runs a program on your machine normally.（有些harness会自动帮你下载，但我没做这个）
• 项目的测试是在我Windows电脑上的Zen browser上进行，如果你的浏览器出现了问题，先问问agent可能是什么，再反馈给我，我会调查。