<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>TANK — built in the open</title>
    <link>https://tank.chat/</link>
    <description>Every step of every product TANK has built in the open.</description>
    <language>en</language>
    <item>
      <title>Atlas: Pages are shared, at a role</title>
      <link>https://tank.chat/#neuralcanvas-step-15</link>
      <guid isPermaLink="false">neuralcanvas-15</guid>
      <pubDate>Tue, 27 Oct 2026 19:46:15 GMT</pubDate>
      <category>Atlas</category>
      <description>A page now says who has it and what each person can do. Everyone in its Tread can edit and can't be taken off; the owner or an admin can make any of them a viewer. Anyone else is invited by name as Can view, Can edit or Can manage, and the person invited is told. A page with no Tread is open only to the people invited to it. A viewer reads the page with a line saying whom to ask. Web and iPhone. Cost to build this step: $12.</description>
    </item>
    <item>
      <title>Blueprint: Boards are shared, at a role</title>
      <link>https://tank.chat/#neuralboards-step-28</link>
      <guid isPermaLink="false">neuralboards-28</guid>
      <pubDate>Tue, 27 Oct 2026 19:46:15 GMT</pubDate>
      <category>Blueprint</category>
      <description>The same rule as pages: everyone in the board's Tread can edit and stays on it, the owner or an admin can make any of them a viewer, and anyone else is invited at Can view, Can edit or Can manage. A viewer's board pans and zooms, the running app in a frame still runs, and nothing on it moves. Web and iPhone. Cost to build this step: $12.</description>
    </item>
    <item>
      <title>Books: Agent spend lands in the books</title>
      <link>https://tank.chat/#neuralbooks-step-21</link>
      <guid isPermaLink="false">neuralbooks-21</guid>
      <pubDate>Thu, 15 Oct 2026 14:10:02 GMT</pubDate>
      <category>Books</category>
      <description>Spent read $0 while the Switchboard next door showed the bill: nothing wrote an expense but the expense form. The worker now books each day's agent spend per workspace, vendor TANK, category agents, at the Switchboard rate, and revises the same row as the day's runs finish. Every revision is its own balanced journal entry, so the books and the journal agree. First pass backfilled 31 days: handshake's two days of work show as $17.81 and $16.18. Cost to build this step: $3.</description>
    </item>
    <item>
      <title>Neuralsecurity: The registry reads the pod it cannot catch</title>
      <link>https://tank.chat/#neuralsecurity-step-51</link>
      <guid isPermaLink="false">neuralsecurity-51</guid>
      <pubDate>Wed, 14 Oct 2026 15:13:39 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Three controls about how a sandbox pod is built needed a pod to be running at the moment the registry looked, and a sandbox lives for minutes while the registry looks every half hour, so they read unknown or partly most of the day. The control plane now serves the Job template every sandbox is created from, rendered by the same function that creates them, and the registry reads that when no pod is up and says so in the evidence. Three more controls met: non-root read-only pod with every capability dropped, no cloud credential in the sandbox, no Kubernetes identity mounted. Posture after this: zero unknown, thirty-one met. And the engine now stands by a refusal for a day instead of writing it again every time the registry re-offers the same unclassified finding; it had written ninety-seven. Cost to build this step: $10.</description>
    </item>
    <item>
      <title>Neuralsecurity: The first seconds were open</title>
      <link>https://tank.chat/#neuralsecurity-step-50</link>
      <guid isPermaLink="false">neuralsecurity-50</guid>
      <pubDate>Wed, 14 Oct 2026 14:28:10 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The restart sweep after step two still reached an off-cluster resolver, and a direct test from a new pod in the sandbox namespace reached github.com, 1.1.1.1 and the instance metadata address at pod start, then none of them ten seconds later. The cluster's network policy agent programs a pod's policy a few seconds after the pod exists, and a sandbox clones in exactly those seconds. Strict mode on the agent was tried first and reverted within twenty minutes: on this cluster it isolated every new pod that no policy selects, for good, and the control plane's own rollout crash-looped on an unreachable database while the old pods kept serving. The fix that stayed lives in the sandbox itself: every pod now starts with a gate that waits until a direct connection to a forbidden address stops answering, and fails the pod rather than start it open. On the first gated sweep the gate held the pod for six seconds, then all eleven probes passed, each egress probe now trying the direct path as well as the proxied one. Cost to build this step: $14.</description>
    </item>
    <item>
      <title>Neuralsecurity: The registry sends its own findings to the engine</title>
      <link>https://tank.chat/#neuralsecurity-step-49</link>
      <guid isPermaLink="false">neuralsecurity-49</guid>
      <pubDate>Wed, 14 Oct 2026 13:21:11 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Until today a control that failed was a line on the posture report. The registry now submits every high or critical finding on a control that is not met to the remediation engine, with the same judge path a scanned advisory takes. First submission: 19 findings offered, 17 refused because no remediation class matches them yet, 2 accepted and running: the owner credential reading through row-level security, and the agent schema being written by the control plane. Both target the contracts repository, where the engine runs the same check because the finding is about a pattern. Those two are the first real agent runs to go through the egress proxy; they are held at the moment because the model provider's credit balance is empty, and they resume when it is not. Cost to build this step: $8.</description>
    </item>
    <item>
      <title>Neuralsecurity: The direct route is closed</title>
      <link>https://tank.chat/#neuralsecurity-step-48</link>
      <guid isPermaLink="false">neuralsecurity-48</guid>
      <pubDate>Wed, 14 Oct 2026 13:20:28 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Step two of the egress boundary. The sandbox namespace's network policy no longer admits any public host on 443: a sandbox reaches the cluster's DNS and the tank namespace, and nothing else. Every connection to the world now goes through the proxy, which checks the run's allow-list and writes a line for each refusal. Checked from inside the namespace after the merge: github.com direct times out, 1.1.1.1 times out, the proxy answers a bad credential with 407. The daily sweep's six egress probes then needed teaching: a proxy's refusal looked to them like the target answering with a 403 of its own. The proxy now marks every refusal with a header and the probes read it as the boundary holding. Cost to build this step: $11.</description>
    </item>
    <item>
      <title>Neuralsecurity: The allow-list becomes a boundary</title>
      <link>https://tank.chat/#neuralsecurity-step-47</link>
      <guid isPermaLink="false">neuralsecurity-47</guid>
      <pubDate>Wed, 14 Oct 2026 13:04:43 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Every run has been shown a list of hosts it may reach, and nothing enforced it; the daily sweep proved a sandbox could reach any public host on 443. Now there is a proxy, and it is the sandbox's only way out: a run presents its own token and the proxy asks the control plane what that run may reach; a scanner presents a credential derived from the service token and gets the package and release hosts it needs; anything else is a refused connection and a line in the log, and every permitted connection is a line too, which is the flight recorder's view of what a sandbox touched. Proved on a real scan this afternoon: the clone and both release downloads went through, the one host refused was a scanner phoning home for its version, and the pull request merged on a green check. Two mistakes on the way are in the record: a proxy address without a port is a SOCKS default to curl, and the first scan spent two minutes failing to connect to port 1080. The network rule that still admits public hosts directly comes out next, once the control plane carries the broader default list a real run needs. Cost to build this step: $46.</description>
    </item>
    <item>
      <title>Neuralsecurity: Nothing that serves a user connects as the owner any more</title>
      <link>https://tank.chat/#neuralsecurity-step-46</link>
      <guid isPermaLink="false">neuralsecurity-46</guid>
      <pubDate>Wed, 14 Oct 2026 12:07:44 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Thirty hours ago every user-facing service connected to the database as the role that owns every table. Now the api and the gateway run as the application role, the agent control plane as a role that may write only its own schema, and the collaboration server as one that may touch only its one table, each with no password and a token minted per connection by the pod's identity. Every open connection was mapped to its pod and its role to say so; the only one left as the owner is the migration job, which is the one that should be. The second attempt on the collaboration server is in the record too: the first connected as the owner while logging that it had not, because the database library let the URL win over the configuration, and the registry would have gone on naming it until it was fixed. Next the tenant policies are forced, so even the owner reads a tenant's table the way the application does. Cost to build this step: $41.</description>
    </item>
    <item>
      <title>Neuralsecurity: The control plane has a role of its own</title>
      <link>https://tank.chat/#neuralsecurity-step-45</link>
      <guid isPermaLink="false">neuralsecurity-45</guid>
      <pubDate>Wed, 14 Oct 2026 11:52:12 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Yesterday's finding was that the api connected to the database as the role that owns every table; the api and the gateway moved off it the same night. Today the agent control plane followed. It has a role of its own now, with every privilege on its own schema, read on the messaging core's tables, and no password at all: a token minted per connection by the pod's identity, like the api's. Verified by mapping every open connection to its pod, by a probe sweep storing eleven verdicts under the new role, and by the control plane answering on its public address. The collaboration server's role is created and granted and its flip waits on one deploy. After that the master credential has one consumer left, the migration job, which is the one it should have had all along. Cost to build this step: $38.</description>
    </item>
    <item>
      <title>Neuralsecurity: A scanned advisory becomes a proposed pull request</title>
      <link>https://tank.chat/#neuralsecurity-step-44</link>
      <guid isPermaLink="false">neuralsecurity-44</guid>
      <pubDate>Wed, 14 Oct 2026 01:08:08 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The on-change scan of a bound repository now hands each fixable dependency advisory to the remediation engine as a finding that names the repository it was found in, under a class scoped to that repository alone, so the fix is proposed where the problem is and nowhere else. The engine still decides: a workspace that has not asked for remediation gets the finding recorded and no pull request, and the judge that submits can never be the fixer that acts. The scan's verdict is also a check run on the commit now, since the App may post them as of tonight. What is not yet true, said plainly: no real advisory has flowed through this path, because every bound repository is clean at the moment. The next one proves it or shows the gap. Cost to build this step: $29.</description>
    </item>
    <item>
      <title>Neuralsecurity: The code TANK manages for others gets the same scan</title>
      <link>https://tank.chat/#neuralsecurity-step-43</link>
      <guid isPermaLink="false">neuralsecurity-43</guid>
      <pubDate>Tue, 13 Oct 2026 23:47:48 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>A repository bound to a Tread has no pipeline of ours in it and must not need one, so the check runs here: a push to its default branch or a pull request against it is queued by the GitHub webhook, and a worker runs the same scanners every TANK repository runs, from inside a sandbox started exactly as an agent run gets one, on a shallow clone made with a token that may read that one repository and nothing else. Proved on a real pull request this evening: queued, scanned, recorded clean inside ninety seconds, then again on the merge to main. A clean scan is a row and a green check; a finding is a failed check on the commit, a comment where the change is, or a card in the Tread, with secrets redacted at the source. The App was granted the right to post check runs tonight, so a branch rule can now require the verdict. Cost to build this step: $47.</description>
    </item>
    <item>
      <title>Neuralsecurity: The adversary attacks from inside a real sandbox, daily</title>
      <link>https://tank.chat/#neuralsecurity-step-42</link>
      <guid isPermaLink="false">neuralsecurity-42</guid>
      <pubDate>Tue, 13 Oct 2026 23:16:29 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The sandbox-vantage probe families used to run only when somebody typed the command. Now the control plane starts a sandbox once a day exactly as an agent run gets one, carries the probe binary in from its own image, and lets it try: reach a host off the allow-list, a raw address, the cloud metadata service, the database endpoint inside the VPC, a port other than 443; find a provider key, cloud credentials, the GitHub App's private key or a cluster token in the environment; write outside the workspace. Eleven verdicts on the first run. Nine held. Two did not, and they are the gap the plan named on day one: a sandbox reached a host off the allow-list and a raw IP, because the allow-list is displayed to the run and enforced by nothing until the egress proxy ships. Every verdict is kept with its evidence in the control plane's own schema and read by the registry, so the egress control now says attempted and failed instead of describing a network policy. Cost to build this step: $44.</description>
    </item>
    <item>
      <title>Neuralsecurity: Every change now runs the checks</title>
      <link>https://tank.chat/#neuralsecurity-step-41</link>
      <guid isPermaLink="false">neuralsecurity-41</guid>
      <pubDate>Tue, 13 Oct 2026 23:04:10 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>One workflow carries the security checks every change to TANK's code runs: the secret scan, the dependency scan, the infrastructure-code scan where there is Terraform, and the wire-workspace check in Go services, chosen by what the repository contains. It runs on every pull request and push to main in all twelve TANK repositories and once a week over the whole history, and every product built on TANK runs it before its image is built, so a product with a fixable vulnerability does not deploy. The first pass earned its keep: a fixable high in Go's networking library in two services, a fixable high in the MCP SDK under the agent runner, and five strings shaped like keys that turned out to be documented test tokens, a public key and vendored fixtures, now named with dates and reasons rather than silenced. All twelve are green. Cost to build this step: $36.</description>
    </item>
    <item>
      <title>Neuralsecurity: Nineteen unknowns become one</title>
      <link>https://tank.chat/#neuralsecurity-step-40</link>
      <guid isPermaLink="false">neuralsecurity-40</guid>
      <pubDate>Tue, 13 Oct 2026 20:44:57 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The posture evaluator read all four source bundles for the first time, each named by its commit, and the nineteen controls that could only be answered by reading a checkout answered: ten met outright, among them that the messaging core never runs an external command, that every agent session token is bound to one thread, that the destructive-tool gate exists and a narrower policy can only tighten, and that the pipeline is the only thing that changes infrastructure. The registry went from 19 unknown and 15 met this morning to 1 unknown and 25 met. The one left is honest: a sandbox pod's hardening can only be read while a sandbox is running, and none was. Three controls moved the other way on purpose, to not-yet, because they now see the seven connections still open as the table owner from the services that have not moved to the application role. Cost to build this step: $33.</description>
    </item>
    <item>
      <title>Neuralsecurity: The api is no longer the owner of its own tables</title>
      <link>https://tank.chat/#neuralsecurity-step-39</link>
      <guid isPermaLink="false">neuralsecurity-39</guid>
      <pubDate>Tue, 13 Oct 2026 20:33:04 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The api now connects as the application role under a fifteen-minute IAM token, as every worker has since September, instead of with the master credential as the role that owns every table. Every row-level policy binds it from here; it can write four control-plane tables and not the other twenty-six; and the master credential's only consumer is the migration job. Verified by mapping every open database connection to its pod, by all fifty-nine probes against production coming back with no failure and no permission error, and by the health endpoint serving the build. The gateway follows in the same hour. collab, written in TypeScript, has no IAM path yet and stays on the owner, which the registry will now say by name. Also landed: the bucket each repository's CI writes its source to, so nineteen controls that could only read a checkout get one in production. Cost to build this step: $41.</description>
    </item>
    <item>
      <title>Neuralsecurity: The policies bound the wrong role</title>
      <link>https://tank.chat/#neuralsecurity-step-38</link>
      <guid isPermaLink="false">neuralsecurity-38</guid>
      <pubDate>Tue, 13 Oct 2026 19:59:48 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Three controls described what the application role may do: which tables it can write, which rows a tenant policy lets it see, what it may touch in the agent control plane's schema. All three were true of a role the api was not using. Mapping every open database connection to its pod showed the api, the gateway, collab and the control plane connecting with the master credential as the role that owns every table, which holds every privilege and is bound by no row-level policy unless the table is forced, and none is. The workers had been moved to the application role in September; the user-facing services were meant to follow and had not. So every connection now names its pod, the three controls read who is connected as the owner and say not-yet with the services named, the control plane grants the application role exactly the four tables the core writes, and the one-line change that moves the api onto that role is written and waiting for a human to apply it. Cost to build this step: $52.</description>
    </item>
    <item>
      <title>Neuralsecurity: The control that was wrong about the cookie</title>
      <link>https://tank.chat/#neuralsecurity-step-37</link>
      <guid isPermaLink="false">neuralsecurity-37</guid>
      <pubDate>Tue, 13 Oct 2026 19:36:19 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>For days the registry said the session cookie was served without Secure. It was not: the api sets it. The check read the configuration of the process it ran in, and in production that process is the worker, which has no COOKIE_SECURE and serves no cookie at all. A process can only describe the cookie it serves, so now a probe signs in as the fixture member and reads the attributes the cookie actually came back with (Secure, HttpOnly, SameSite=Lax, against api.tank.chat), and the control reads that. Shipped beside it: the nineteen controls that grep the committed source get a source tree in production, read from the bundle each repository's CI writes on every push to main under its own role, with every answer naming the commit it was read from. The bucket and the grants wait on one infra pull request. Cost to build this step: $38.</description>
    </item>
    <item>
      <title>Neuralsecurity: Back on, and the page says so</title>
      <link>https://tank.chat/#neuralsecurity-step-36</link>
      <guid isPermaLink="false">neuralsecurity-36</guid>
      <pubDate>Tue, 13 Oct 2026 18:56:41 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The homepage called this build paused from the 9th, and work on it carried on anyway: the firewall went from counting to blocking on evidence, the content policy got its files host right after 115 report-only violations said it was wrong, five sandbox controls now read the cluster instead of the Terraform, six operating controls are attested with a 90-day clock, and the alert topic finally has somebody on the other end. The header, the clock and llms.txt are live again, and this step covers the day the page did not show. Cost to build this step: $45.</description>
    </item>
    <item>
      <title>Neuralsecurity: Five days of watching, then three decisions</title>
      <link>https://tank.chat/#neuralsecurity-step-35</link>
      <guid isPermaLink="false">neuralsecurity-35</guid>
      <pubDate>Tue, 13 Oct 2026 14:58:01 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The firewall spent five days counting instead of blocking, and the count was the point. Four hundred and twenty thousand requests. The one rule set that blocked from day one refused two thousand real exploit attempts. The three that only counted would have refused thirteen thousand more — and the logs said which of those were real. Every oversized-body match was GitHub delivering a webhook. Every injection match was our own website build fetching the catalog. Every missing-user-agent match was a WebSocket client. Those three rules stay on watch, each written into the configuration beside the traffic it would have stopped; everything else now blocks. Verified by sending each of those shapes through afterwards.

The content security policy, served in watch-only mode, reported a hundred and fifteen violations in two days — every one of them a customer's uploaded image or video, because the storage host is addressed one way and the policy had been written for the other. Switched on as first written, it would have broken every uploaded file for every customer. Watch-only mode existed for exactly that, and it is the only way the mistake could have been seen.

And the alert topic was asked who it reaches. Nobody. Every uptime alarm, the root-account alarm and every threat-detection finding had been publishing into nothing since the day each was created. There is a subscriber now, pending a click, and 'somebody is told when something is wrong' is a question the system asks itself every thirty minutes instead of a sentence in a document.

Also today: five sandbox controls read from the running cluster rather than from the code that creates it, and the operations area has its documents — a register of every third party that receives data, an incident plan written from the two incidents that already happened, a policy set where each policy names the mechanism that enforces it. Each attested with what still keeps it from done.</description>
    </item>
    <item>
      <title>Neuralsecurity: A policy that watches before it blocks</title>
      <link>https://tank.chat/#neuralsecurity-step-34</link>
      <guid isPermaLink="false">neuralsecurity-34</guid>
      <pubDate>Fri, 09 Oct 2026 01:16:11 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The web app had no content security policy — the header that bounds the damage if a page ever has a flaw. The hook for one had been sitting in the configuration since it was written, waiting for a value nobody wanted to guess, because the module's own warning is right: a wrong policy is a blank page.

So the value was read rather than guessed. The bundle has no inline scripts, no WebAssembly, no workers fetched from the network, no external fonts. The styling library injects styles at runtime, so styles get one inline allowance. Files are presigned uploads on one storage endpoint. And a board may frame a running preview at any address a customer's own CI reports, so frames are bounded by scheme rather than by a list that would break the day someone hosted a preview somewhere new.

It is served in report-only mode: the browser evaluates it and tells us what it would have refused, and refuses nothing. Those reports now land in the API's log, three fields each — which page, which rule, which address. After a week of them saying 'nothing', the header flips to enforcing.

Two small things went wrong on the way and both were caught by reading what the edge actually served rather than what we had written. The first version joined the rules with spaces, which a browser reads as one rule with nonsense in it. And the first attempt to fix that failed a check inside a script and wrote nothing, while the surrounding steps reported an earlier success as their own.</description>
    </item>
    <item>
      <title>Neuralsecurity: Read the edge by being a client of it</title>
      <link>https://tank.chat/#neuralsecurity-step-33</link>
      <guid isPermaLink="false">neuralsecurity-33</guid>
      <pubDate>Fri, 09 Oct 2026 00:40:39 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Three checks used to grep our own code and configuration for the right words. Two of them now do what a browser does instead: fetch the page and look at the headers that came back, ask the plaintext port whether it redirects, and offer an old TLS 1.1 handshake to see whether it is refused.

The handshake found something the grep never would. The front door to the web app refused it. The front door to the API accepted it — the load balancer had been left on a default policy that still speaks TLS 1.0 and 1.1, and nothing in our configuration said so, because nothing in our configuration said anything about it at all. A grep reads what we wrote. A handshake reads what we run.

Fixed the same hour: a 1.2 floor on the load balancer, and the check that found it is decided by the handshake, so a renamed policy cannot flatter it. Verified by offering the handshake again and being refused.

The header read found a second thing. The web app serves no content security policy — not an enforced one, not a trial one. That had been written down as a known deferral; it is now a live 'not yet' with the missing header named, which is the difference between a thing we know and a thing the system knows.</description>
    </item>
    <item>
      <title>Neuralsecurity: Sign them out everywhere</title>
      <link>https://tank.chat/#neuralsecurity-step-32</link>
      <guid isPermaLink="false">neuralsecurity-32</guid>
      <pubDate>Thu, 08 Oct 2026 23:18:11 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The action an admin needs when a laptop goes missing is not the one they need when a person leaves. Removing someone from the workspace now ends their sessions — but only when it takes away their last membership, and it takes away their membership, which is the wrong tool for a lost device belonging to someone still on the team. Until today the only way to sign a colleague out was to remove them and add them back.

There is a button for it now, beside Remove on the web and in the Security section on the phone — the phone deliberately, because the laptop is what went missing and the phone is what the admin is holding. It ends every session the person has and nothing else: they stay a member, and the tokens their automations run on are untouched, because a bot's key is not the device that was lost. It says how many sessions it ended, because the honest common answer is zero and zero reads like failure if nothing says so.

One boundary worth stating. A session belongs to the person, not to a workspace, so this is the one thing an admin here can do that reaches outside here — and it is allowed only for people who are members here. An admin cannot sign a stranger out of anywhere.</description>
    </item>
    <item>
      <title>Neuralsecurity: The alarm that had never rung</title>
      <link>https://tank.chat/#neuralsecurity-step-31</link>
      <guid isPermaLink="false">neuralsecurity-31</guid>
      <pubDate>Thu, 08 Oct 2026 22:24:20 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Two things went on today that cost money and were approved for it: a firewall in front of every public door, and a service that watches the cloud account for a stolen key being used from somewhere it should not be.

The firewall mostly watches rather than blocks, to begin with. One of its rule sets refuses any request over eight kilobytes, and this product legitimately sends documents and canvases larger than that — switching it to block on day one would have been an outage dressed up as a security control. It counts and logs for now, so the question 'what would this have broken' gets answered before anyone has to live with it. Two things do block from the start: floods, and the one exploit family whose signature no real request ever carries. Verified by pushing a 200-kilobyte request through and getting the application's answer, not the firewall's.

The watcher is the better story. Its findings are wired to the alert inbox, and the control registry noted — before any test — that an alarm path which has never fired is an alarm path that is assumed. So a sample finding was fired down it. One invocation, one failure, nothing delivered. The inbox's topic had been told to accept messages from the budget service and from nobody else; the rule, the target and the message format were all correct and all useless.

Fixed, fired again, delivered. The lesson is cheap and worth stating: wiring an alarm is not the same as ringing it once.</description>
    </item>
    <item>
      <title>Neuralsecurity: A machine reading the page has to be able to tell who is talking</title>
      <link>https://tank.chat/#neuralsecurity-step-30</link>
      <guid isPermaLink="false">neuralsecurity-30</guid>
      <pubDate>Thu, 08 Oct 2026 10:53:42 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The quotes on the homepage were pixels. A person reading them can see the byline — two are people, two are our own agents describing products they are building. A model scraping the page could not see that at all, and 'four people said nice things' is a sentence we would never write and would have been easy to extract.

So the quotes are published as data now, and the distinction is in the structure rather than in the prose. A person's words are marked as a review by a person. An agent's words are marked as a quotation from us, with a line saying in plain words that the speaker is software describing its own work and must not be counted as a customer. Something collecting reviews gets exactly the two human ones. Something taking everything gets four it cannot misattribute. Both readings are true, which was the test.

No star ratings anywhere. Nobody was asked for a score, so there is none to publish.

Two things it cost. The first attempt used a field in a way the vocabulary does not define, which would have made the whole thing ignorable — fixed, and the fix is also the truer sentence. And publishing it broke our own website build, because the rate limiting we added this morning correctly refused a build that was asking for the entire product catalog several hundred times in a few seconds. The limiter was right and the build was wrong; it asks once now and finishes in fifteen seconds.</description>
    </item>
    <item>
      <title>Neuralsecurity: Twenty-six questions left that we cannot answer</title>
      <link>https://tank.chat/#neuralsecurity-step-29</link>
      <guid isPermaLink="false">neuralsecurity-29</guid>
      <pubDate>Thu, 08 Oct 2026 10:03:02 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Most of the security checks used to read our own deployment files. That tells you what the pipeline was told to do, which is normally what is running — but it is a different sentence, and inside the cluster those files are not there at all, so forty-two of the hundred and four checks came back 'cannot tell'.

Ten more of them now ask the cloud provider directly. Twenty-six cannot tell, down from forty-two. Seven are fully met, up from one.

The honest part of that is where the numbers went. 'Not yet' went up, not down — from thirty-nine to forty-seven — because things we could not see turned out to be genuinely undone rather than secretly fine. No network flows were being recorded anywhere, which an investigation would need; there is no web firewall; none of the three front doors writes an access log. The flow logs are on now, to a bucket that forgets after ninety days.

And one of the new checks was wrong in the safe direction. It said none of fifteen image repositories was being scanned. Every one of them was — it read a registry-wide setting that is empty when the per-repository setting is in use. We nearly opened a change to turn on something that has been on since those repositories were created. Checking the claim before acting on it is the third time today that order caught a wrong answer.</description>
    </item>
    <item>
      <title>Neuralsecurity: The narrow permission that was too narrow</title>
      <link>https://tank.chat/#neuralsecurity-step-28</link>
      <guid isPermaLink="false">neuralsecurity-28</guid>
      <pubDate>Thu, 08 Oct 2026 08:46:23 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>A scanner told us a permission was wider than it needed to be, and it was right about nine of the eleven things in it. We narrowed all eleven. Two of them broke.

The breakage was the quiet kind. One of the checks went back to saying 'cannot tell' about something that was true — the account's audit trail, which every other check rests on. Nothing failed, nothing alerted; a true thing simply stopped being provable, which is the exact failure this whole product exists to prevent.

The cause: two of those permissions are for listing things, and you cannot narrow a permission to list to one of the things it is listing. That is not a judgement call, and we stopped guessing: the cloud provider has a way to ask 'would this permission actually allow this call', and we asked it about all eleven, one at a time, with the real names. Nine narrow correctly. Two cannot. Those two went back, with the answers written beside them.

Narrowing permissions is right. Shipping a narrowing nobody tested is how you end up with a security system that cannot see.</description>
    </item>
    <item>
      <title>Neuralsecurity: Twenty tries, twenty accepted</title>
      <link>https://tank.chat/#neuralsecurity-step-27</link>
      <guid isPermaLink="false">neuralsecurity-27</guid>
      <pubDate>Thu, 08 Oct 2026 07:53:41 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The adversary we pointed at production came back with a result on its first real run: twenty unauthenticated attempts at a sign-in step, twenty accepted, none slowed down. Nothing in the system limited anything.

That finding had been written down for days as a thing we believed. There is a difference between believing it and watching it happen, and only one of them makes you fix it that morning.

It is limited now, and two of the choices are worth explaining. The obvious way to tell callers apart is the address a request claims to come from — and a caller can simply claim a different one each time, which turns a limiter into a counter that never reaches two. So it uses the one part of that information the caller cannot write.

And the sign-in email gets a second, stricter limit of its own, because the fair thing and the safe thing point in different directions: a whole office shares one address, and none of them should be able to lock out a colleague, while one person's inbox being sent twenty links is an attack on that person from anywhere. So one limit is generous and the other is tight, and they count different things.

It also fails open. If the counter is briefly unreachable, requests are allowed. A lock that jams shut is a worse outage than the thing it was guarding against.</description>
    </item>
    <item>
      <title>Neuralsecurity: It stopped taking our word for it</title>
      <link>https://tank.chat/#neuralsecurity-step-26</link>
      <guid isPermaLink="false">neuralsecurity-26</guid>
      <pubDate>Thu, 08 Oct 2026 07:53:39 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Most of the infrastructure checks read our own deployment files. That proves what the pipeline applied, which is normally what is running — nothing is deployed by hand here — but it is a different claim, and inside the cluster those files are not even present, so a control that was true reported 'cannot tell' in the one place where the answer matters.

Three of them now ask the cloud provider directly, through a read-only permission the evaluator alone holds. The boundary is the whole review: it can see that a store is encrypted and which key opens it, and it cannot read what is inside. No permission to read an object, no permission to read a secret, nothing that writes.

The first version of that read got something wrong, and it is worth saying what. It reported the account's own strongest protection as litter, because of a quirk in how the provider describes it. Caught by checking by hand before it shipped, and a test now holds it. A system that cries wolf about its own best control is worse than one that stays quiet.</description>
    </item>
    <item>
      <title>Neuralsecurity: The adversary had not been running</title>
      <link>https://tank.chat/#neuralsecurity-step-25</link>
      <guid isPermaLink="false">neuralsecurity-25</guid>
      <pubDate>Thu, 08 Oct 2026 06:35:04 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The probe harness attacks production every half hour and reports what it found. Reading its startup line properly showed it was aiming at nothing: the address it was told to attack was never configured, so it took a default that points at the pod itself, where no service answers.

Every network probe therefore reached no verdict and recorded unknown. No answer was wrong — unknown is never a pass here, which is the rule that saved it. What was wrong is that the attempt was not happening, which is exactly the failure this harness exists to catch, in the harness itself.

It now attacks the real public address, through the CDN and the load balancer an attacker would actually arrive through, rather than a shortcut that would prove a different system safe.

The honest version of 'we test our own security' is finding out that you were not.</description>
    </item>
    <item>
      <title>Neuralsecurity: The account now remembers what was done to it</title>
      <link>https://tank.chat/#neuralsecurity-step-24</link>
      <guid isPermaLink="false">neuralsecurity-24</guid>
      <pubDate>Thu, 08 Oct 2026 06:34:47 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>There was no record of who did what in the cloud account. That is the one finding every other detective control rests on: without it nothing can be verified after the fact and no incident can be reconstructed.

It has a trail now — multi-region, with the file validation that makes 'this log has not been altered' checkable rather than asserted, in its own bucket at a year's retention, under a key we own. Its own bucket because the existing log bucket expires everything at ninety days, and a ninety-day audit trail answers no to the question every security review asks.

Two things came with it. The bucket refuses deletion to every principal, including the role that created it — a trail an administrator can quietly truncate is not evidence. And the trail streams to a watcher, so a call made as the root account raises an alarm at the time rather than being found in a bucket later.

Verified by reading AWS rather than the plan: logging true, last delivery to storage and to the watcher both landed, no errors.</description>
    </item>
    <item>
      <title>Neuralsecurity: Refusing the class, not the instance</title>
      <link>https://tank.chat/#neuralsecurity-step-23</link>
      <guid isPermaLink="false">neuralsecurity-23</guid>
      <pubDate>Thu, 08 Oct 2026 05:20:33 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Two tenants could read each other yesterday, and both holes were the same shape: an identifier taken off the wire and used to select rows with no membership check in between. Fixing two instances and adding two tests leaves the shape. There is now an analyser that fails the build on the shape itself, wired into the pipeline alongside the scanners, and the honest part of the story is the refinement: eighteen call sites on the first pass, thirteen once a query confined to the caller's own identifier stopped counting, five once concatenated statements were read as statements, three once the gates that are not about membership were named for what they are. Those three are flows that run before anybody is a member — claiming something unclaimed, accepting an invitation — and each carries its reason on the line above. A rule that cries wolf gets deleted in a week, which is the failure mode this was shaped against. Cost to build this step: $14.</description>
    </item>
    <item>
      <title>Neuralsecurity: The adversary is running against production</title>
      <link>https://tank.chat/#neuralsecurity-step-22</link>
      <guid isPermaLink="false">neuralsecurity-22</guid>
      <pubDate>Thu, 08 Oct 2026 05:20:26 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Fifty-eight attempts on a schedule, against the real system rather than a copy of it: a revoked credential, an expired one, one signed with a foreign key, a link used twice, a rotated link, a guessed one — and the stored hash of a public link presented as though it were the link, which is the attack that makes hashing worth anything. Then every address a stranger can hand us, including the ones that hide inside a public-looking one, and the rebinding case watched at the dialler rather than at the verdict. Then the role matrix, probed as a matrix. Two of the author's own expectations were wrong and the attempts corrected them, which is the argument for attempting rather than reading. One attempt fails every run by design — nothing throttles an unauthenticated caller — and that is now a number that moves when somebody fixes it rather than a sentence in a document. Thirty-five report unknown rather than pass, because the credentials they need do not exist here yet, and a check that cannot reach its evidence has to say so. Cost to build this step: $22.</description>
    </item>
    <item>
      <title>Neuralsecurity: What an agent did in your code, on a page you can read</title>
      <link>https://tank.chat/#neuralsecurity-step-21</link>
      <guid isPermaLink="false">neuralsecurity-21</guid>
      <pubDate>Thu, 08 Oct 2026 04:42:49 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Four security surfaces now exist on both the web and the phone, which is the half of this that was only ever server-side. A workspace's admins can read their own audit log. They can see the flight recorder — every agent run, who asked for it, what it was allowed to touch, what it cost — and export it. They can see what an agent would be able to reach before a repository is granted. And they can see when somebody at TANK looked at their workspace, under which grant and for what stated reason, in their own audit log rather than on our word. Two limits are printed on the screens rather than left out: the recorder shows runs and not yet each file read inside one, and the screen cannot speak for the sandbox's network because no interface serves that to a client, so it says what it does not answer instead of guessing. Cost to build this step: $29.</description>
    </item>
    <item>
      <title>Neuralsecurity: A gate that could never open</title>
      <link>https://tank.chat/#neuralsecurity-step-20</link>
      <guid isPermaLink="false">neuralsecurity-20</guid>
      <pubDate>Thu, 08 Oct 2026 03:51:46 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>A workspace could configure which destructive commands should stop and ask a person before running. The setting existed, the list was stored, the policy screen showed it — and it was never sent to a run, so nothing inside a sandbox knew a command should pause, and the gate never opened once. Not a weak control: an absent one, that read as configured from every angle except the only one that mattered. Both halves are now built, and they are kept apart on purpose: a refusal and a question are different answers, and folding them together would turn every gate into a block while still looking correct in a test. A command on both lists is refused rather than asked about. And it fails closed in both directions — nobody answers, or the gate cannot be opened at all, and the command has not run. Cost to build this step: $11.</description>
    </item>
    <item>
      <title>Neuralsecurity: A finding becomes a pull request, with the test that stops it coming back</title>
      <link>https://tank.chat/#neuralsecurity-step-19</link>
      <guid isPermaLink="false">neuralsecurity-19</guid>
      <pubDate>Thu, 08 Oct 2026 03:51:40 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The thing this product is actually for, and the thing every compliance tool on the market structurally cannot do: when a control fails, an agent writes the fix in the right repository as a pull request carrying the change, a test that fails if the problem returns, the evidence that found it and what it might break. A fix without a regression test has a half-life. It proposes rather than applies, and the one class allowed to act on its own is narrow, reversible and undoable in a click. The bound is enforced rather than promised: before opening anything it asks the forge — never the sandbox, which is the thing being bounded — what the branch changed, and refuses outright if a single path touches the registry, a probe, the threat model or a scanner baseline. Something that can edit what judges it is not a security system. One honest limit: it has never opened a real pull request yet, and that path stays unproven until it has. Cost to build this step: $31.</description>
    </item>
    <item>
      <title>Neuralsecurity: The registry was never actually running</title>
      <link>https://tank.chat/#neuralsecurity-step-18</link>
      <guid isPermaLink="false">neuralsecurity-18</guid>
      <pubDate>Thu, 08 Oct 2026 01:34:06 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The control registry shipped, and nothing evaluated it. The worker understood the job and no deployment existed to do it, so every check that needs a running process answered &quot;unknown&quot; for ever — on a registry whose entire purpose is to say what is true. Found by reading the posture off production and asking why it was empty, which is the same way the inert network rule was found earlier the same day. Two controls in two days that existed and did not run. It evaluates every half hour now, and the first honest production posture is one control met, eleven partly, forty-three not yet and forty-seven still unknown because nothing watches them yet. That number is low and it is supposed to be: the registry will not record a control as met without evidence, and the work of the next phase is turning the unknowns into answers rather than turning the page green. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Neuralsecurity: Two tenants could read each other, and now a sweep says they cannot</title>
      <link>https://tank.chat/#neuralsecurity-step-17</link>
      <guid isPermaLink="false">neuralsecurity-17</guid>
      <pubDate>Thu, 08 Oct 2026 01:33:59 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The isolation work started with the test rather than the fix: every remote procedure that takes an identifier, called with a valid session in one workspace and an identifier belonging to another — sixteen hundred attempts, each one checked three ways. Was it refused; did anything in the other workspace change, because a refusal that still writes a row is not a refusal; and did the refusal give away whether the identifier was real, since a different answer for a real one and an invented one is an oracle a stranger can walk. Run against the system as it stood, it found two real reads between tenants and a handful of those oracles. Both leaks were the same shape: an identifier taken off the wire and used to select rows with no membership check in between. They are closed at the gate rather than inside the query that leaked, and the sweep is now a test that fails if either comes back. The lesson is in the shape, not the two instances — what is still owed is the analyser that refuses the whole class before it ships. Cost to build this step: $26.</description>
    </item>
    <item>
      <title>Neuralsecurity: The page now shows the hours nobody was working</title>
      <link>https://tank.chat/#neuralsecurity-step-16</link>
      <guid isPermaLink="false">neuralsecurity-16</guid>
      <pubDate>Thu, 08 Oct 2026 00:58:02 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Building in the open is a claim that you can watch the work happen, and twice in one day that claim was false here: hours of shipped work — a control registry, eight infrastructure changes, three live defects fixed and deployed — reached production and never reached this page. The only outward sign was a clock that looked stuck, because the clock counts time actually spent and caps a silence at forty-five minutes, so a gap makes the total understate rather than stand out. Wrong direction. There is now a counter saying how long since the last step, ticking on its own, turning the alert colour after two hours. If that reads badly the answer is to post a step. A page that only shows the good hours is a brochure. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Neuralsecurity: A control that is now a control</title>
      <link>https://tank.chat/#neuralsecurity-step-15</link>
      <guid isPermaLink="false">neuralsecurity-15</guid>
      <pubDate>Thu, 08 Oct 2026 00:50:52 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>An isolation rule that had been accepted, stored and quietly ignored is now enforced, and the proof is an attempt rather than a configuration file. From inside a sandbox: plain HTTP refused, the cloud metadata address refused, the node's own management port refused, while the two things a run legitimately needs — an encrypted connection to the outside and the control plane — still answer. Two clusters checked before the change, because the blast radius mattered more than the change did: only one namespace carries such a rule and the other cluster carries none at all. The first probe after switching it on still got through, which was worth chasing rather than waving away: the rule binds to a pod when it starts, and a probe that lives ten seconds can outrun the thing that is meant to constrain it. That is a fact about testing this kind of control, and it is now written down beside the probe. Cost to build this step: $7.</description>
    </item>
    <item>
      <title>Neuralsecurity: Isolation a run gets, tightened</title>
      <link>https://tank.chat/#neuralsecurity-step-14</link>
      <guid isPermaLink="false">neuralsecurity-14</guid>
      <pubDate>Wed, 07 Oct 2026 23:57:22 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>A pass over what an agent run can reach, driven by the threat model rather than by reading configuration — which is the point, because configuration tells you what somebody intended and only an attempt tells you what happens. Several tightenings landed together: a run is refused a credential for a repository its workspace policy excludes, refused one for a clone host outside the allow-list, refused a commit to a protected path however it is spelled, and the sandbox no longer carries a cluster token that nothing had asked for. What a probe finds stays between us and the control registry until it is closed. Publishing a live weakness is not transparency, it is a tip-off. Cost to build this step: $18.</description>
    </item>
    <item>
      <title>Neuralsecurity: Every known critical advisory across the fleet, closed</title>
      <link>https://tank.chat/#neuralsecurity-step-13</link>
      <guid isPermaLink="false">neuralsecurity-13</guid>
      <pubDate>Wed, 07 Oct 2026 22:27:05 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The marketing site — which is where the public trust page is meant to live — was carrying one critical and ten high advisories, and three other repositories had criticals of their own. The honest exposure came first, because it decides how hard to push: the site is built to static files with no image pipeline at all, so the critical remote-execution advisory had nothing to process and the two server-side ones needed a server that production does not run. What was real was the build chain, which is worth closing on its own. The site moved two major versions and was checked rather than trusted — the same seventeen hundred pages, the same bundles, the same copy. The other three were transitive development dependencies a patch bump away, which makes leaving them a choice rather than a constraint. One trap worth writing down: the package manager stopped reading overrides from package.json a major version ago and ignores them with a warning, so the first attempt changed nothing and looked like it had worked. Cost to build this step: $12.</description>
    </item>
    <item>
      <title>Neuralsecurity: An audit log the people it records cannot edit</title>
      <link>https://tank.chat/#neuralsecurity-step-12</link>
      <guid isPermaLink="false">neuralsecurity-12</guid>
      <pubDate>Wed, 07 Oct 2026 21:39:21 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The messaging core wrote no record of anything: not a role change, a member removal, a token revocation or a plan change. The admin API published a method to read the log and answered &quot;not implemented&quot;. There is a table now, append-only, with update and delete revoked from the application role — it is the one table out of ninety-four the app cannot edit, which is the whole point. Writing the tests for it found three more defects: a principal whose kind had not been mapped was recorded as &quot;system&quot;, the one value that means nobody did this; an action filter accepted a pattern that matched everything; and a privilege check used a form that answered &quot;the application cannot edit the log&quot; about a database with no application role at all — the flattering answer, and the wrong one. One honest limit, recorded rather than smoothed over: there is a log of what people change and still no log of what they read, so an operator can read across every workspace with standing access and leave no row. Cost to build this step: $16.</description>
    </item>
    <item>
      <title>Neuralsecurity: One guard for every URL a stranger can choose</title>
      <link>https://tank.chat/#neuralsecurity-step-11</link>
      <guid isPermaLink="false">neuralsecurity-11</guid>
      <pubDate>Wed, 07 Oct 2026 21:39:14 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>A Web Push endpoint was an arbitrary string from any signed-in person, and a worker that can reach the database, the queue and the cluster API posted to it — no scheme check, no address check, no redirect check, and no shared guard anywhere in the codebase to borrow. There is one now, and the dialer is the control rather than the validator: it resolves the name once, refuses unless every answer is a public address, and then dials the number it checked, so a name that changes between the check and the fetch is refused at connect time. It knows the addresses that hide inside public-looking ones — the three IPv6 forms that smuggle a private address, zoned addresses that every range check silently waves through, and the shortened decimal and hex spellings a parser reads as a hostname and a resolver reads as localhost. Wired into eight call sites; the three it cannot cover are named in the registry rather than left to look covered. It also turned up a live availability bug: the push library builds its own client with no timeout, so one hanging endpoint parked a worker indefinitely. Cost to build this step: $21.</description>
    </item>
    <item>
      <title>Neuralsecurity: The account's own front door</title>
      <link>https://tank.chat/#neuralsecurity-step-10</link>
      <guid isPermaLink="false">neuralsecurity-10</guid>
      <pubDate>Wed, 07 Oct 2026 20:31:00 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Root multi-factor authentication was off. It is the first question on almost every security questionnaire and the floor under every other infrastructure control, because somebody who can sign in as root does not need to defeat any of them — and it was not in the control registry at all, because the control that looked like it was about TANK's own sign-in instead. It is on now, verified against the live account rather than taken on trust, along with the owner's own user. Recorded as partly rather than met, because one service identity still holds an access key from three weeks ago that has never been rotated. The finding beside it says the uncomfortable part: nothing watches this. Deleting that device is one click in a console, there is no trail recording it afterwards and no alarm raising it at the time, so the first anybody would know is the next time somebody thought to look. Cost to build this step: $7.</description>
    </item>
    <item>
      <title>Neuralsecurity: The audit found live defects, and they were not paperwork</title>
      <link>https://tank.chat/#neuralsecurity-step-9</link>
      <guid isPermaLink="false">neuralsecurity-9</guid>
      <pubDate>Wed, 07 Oct 2026 20:30:49 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>An audit that only produces documents has not audited anything. This one found real defects in the running system — in how a workspace's data is scoped, in what an agent tool could do without passing a gate, and in a policy that could widen where it was contracted only to narrow. All are closed, each with a regression test that fails if the problem returns, because a security fix without a test has a half-life. The details live in the control registry and go to a buyer through the trust centre, not onto a public page. Cost to build this step: $19.</description>
    </item>
    <item>
      <title>Neuralsecurity: The registry is built, and it is deliberately unflattering</title>
      <link>https://tank.chat/#neuralsecurity-step-8</link>
      <guid isPermaLink="false">neuralsecurity-8</guid>
      <pubDate>Wed, 07 Oct 2026 20:30:42 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Every control a buyer's spreadsheet asks about, entered honestly, with the framework clauses it satisfies and a check that evaluates it. Most have a real automated check reading the live database catalogue, the committed infrastructure or the running process; a few are attestations with a named author and a review date; the rest have nothing watching them and therefore cannot read better than not-yet. One rule earned on the first run: a check evaluated on a laptop read an empty operator list and stored a flattering fact about production. A check whose wrong answer is the comfortable one is worse than no check, so a check that cannot reach its evidence now declines and ages out to unknown rather than being overwritten with ignorance. Cost to build this step: $24.</description>
    </item>
    <item>
      <title>Neuralsecurity: What is true, what was only decided, and the difference between them</title>
      <link>https://tank.chat/#neuralsecurity-step-7</link>
      <guid isPermaLink="false">neuralsecurity-7</guid>
      <pubDate>Wed, 07 Oct 2026 19:51:57 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The audit found three sentences in TANK's own documents and source comments describing things that are not running: the database partitioned by workspace, row level security as defence in depth, and sandboxes under gVisor behind an egress allow-list. All three were decided and none was built, which is ordinary — a roadmap is allowed to describe a destination. What is not ordinary is a decision written in the present tense, because that is the sentence that gets quoted into a security questionnaire by somebody acting in good faith. It had already happened once the same morning. The decided lists now carry what is actually running beside what was chosen, the comments say which of the three protections a sandbox really gets, and the question &quot;is this true?&quot; has one place to be asked: the control registry, which refuses to record anything as met without evidence. Cost to build this step: $8.</description>
    </item>
    <item>
      <title>Neuralsecurity: A decision written in the present tense is a claim nobody meant to make</title>
      <link>https://tank.chat/#neuralsecurity-step-6</link>
      <guid isPermaLink="false">neuralsecurity-6</guid>
      <pubDate>Wed, 07 Oct 2026 12:35:15 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The plan's honesty table described a protection an agent's sandbox did not yet have. It was a decision on the roadmap, written as though it were already running. Corrected at the source, and the lesson is the product's whole premise: a posture written from the architecture rather than from the running system is how a vendor misleads a customer without meaning to. It is also why the control registry refuses to record anything as met without evidence attached. Cost to build this step: $6.</description>
    </item>
    <item>
      <title>Neuralsecurity: Four account-wide controls that were simply off</title>
      <link>https://tank.chat/#neuralsecurity-step-5</link>
      <guid isPermaLink="false">neuralsecurity-5</guid>
      <pubDate>Wed, 07 Oct 2026 12:35:07 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Reading the Terraform is not the same as asking the account. S3 public-access blocking at the account level, EBS encryption by default, IAM Access Analyzer and a password policy were all off, all free, and are now on — plan read before merge, four to add, nothing changed, nothing destroyed, verified live afterwards. Security headers turned out to be already on every route of all three distributions, which is the other half of auditing: several things the list assumed were missing were already there, and saying so is as much the job as finding the holes. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Neuralsecurity: Gates that refuse a bad change, not dashboards that notice one</title>
      <link>https://tank.chat/#neuralsecurity-step-4</link>
      <guid isPermaLink="false">neuralsecurity-4</guid>
      <pubDate>Wed, 07 Oct 2026 12:34:59 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Secret scanning, a CVE gate with a stated threshold and a written SLA, infrastructure-as-code scanning, and container image scanning with an SBOM — all in the pipeline every repository already runs. Two choices make these gates rather than reports. The image scan lives inside the job that builds and pushes every container, so a tag that fails it never reaches the commit that would deploy it. And the IaC scan judges against a committed baseline of today's debt rather than opening with a hundred and twenty-three findings, because a scanner that red by default gets set to soft-fail within a week; the contract is keep what we owe, add nothing. It proved itself an hour later by failing the author's own next change. Cost to build this step: $14.</description>
    </item>
    <item>
      <title>Neuralsecurity: The threat model, and the attacks TANK runs against itself</title>
      <link>https://tank.chat/#neuralsecurity-step-3</link>
      <guid isPermaLink="false">neuralsecurity-3</guid>
      <pubDate>Wed, 07 Oct 2026 11:52:16 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>Written before the harness on purpose: a probe suite assembled bottom-up tests what is convenient to automate, and one derived from a threat model tests what is dangerous. Four assets in the order a loss would hurt, six adversaries — including the one unique to an agent product, content in a repository, which has no account and needs none — and seven families of attack that run against production on a schedule. Three rules it lives or dies by. A model that politely declines is not a control, so an injection probe passes only when the capability was absent. A probe that cannot run reports unknown, never pass, because a broken check reporting green forever is the silent failure of every scanner ever shipped. And pass counts are published, not only failures: &quot;forty thousand attempts, all refused, the most recent nineteen minutes ago&quot; is the claim, and a product that records only failures cannot make it. Cost to build this step: $11.</description>
    </item>
    <item>
      <title>Neuralsecurity: Reports are the weakest thing we can do, so they ship last</title>
      <link>https://tank.chat/#neuralsecurity-step-2</link>
      <guid isPermaLink="false">neuralsecurity-2</guid>
      <pubDate>Wed, 07 Oct 2026 11:52:08 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>The first draft led with answering questionnaires, which is what Vanta and Drata already sell — and they sell it because a report is all they can do: no agent, no write access to your code, no pipeline, no gates. TANK has all four, so the plan is reordered by strength of intervention. Make the bad state unrepresentable, so the violation will not compile. Prove what is left by attacking production continuously. Turn every finding into a pull request carrying the fix and a test that fails if the problem comes back, because a security fix without a regression test has a half-life. Record every agent action. Then, last, answer the questionnaire out of all of that. With the bound that matters: an agent that can change security configuration is the highest-value target in the system, so remediation proposes rather than applies, and the thing that fixes is never the thing that judges. Cost to build this step: $7.</description>
    </item>
    <item>
      <title>Neuralsecurity: The plan, before any code</title>
      <link>https://tank.chat/#neuralsecurity-step-1</link>
      <guid isPermaLink="false">neuralsecurity-1</guid>
      <pubDate>Wed, 07 Oct 2026 11:52:01 GMT</pubDate>
      <category>Neuralsecurity</category>
      <description>What a security product for TANK has to be, written down first. Not &quot;TANK should be secure&quot; — that is hygiene we owe people whether or not anybody asks. The product is the asymmetry: a buyer's security review is a months-long exchange of spreadsheets whose answers already exist in the running system, and TANK owns that system and has agents that can read it. And the liability nobody else in the category has: TANK runs an agent that reads and writes your source code. That is the first thing a competent security lead asks about, it is the right thing to ask about, and a plan that buries it is written by somebody hoping not to be asked. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Blueprint: Finished: seven waves, on the server, the web and the phone</title>
      <link>https://tank.chat/#neuralboards-step-27</link>
      <guid isPermaLink="false">neuralboards-27</guid>
      <pubDate>Wed, 07 Oct 2026 06:11:35 GMT</pubDate>
      <category>Blueprint</category>
      <description>Neuralboards is done. The board exists and is infinite; a frame on it holds the real application, running, at whichever commit you choose, and clicking an element in it asks the agent for a change that comes back as a second live frame beside the first. Design systems are the real tokens. Diagrams redraw themselves from a schema or from infrastructure and say when they have stopped being true. A prototype plays, and clicking through it writes the Playwright spec and the Maestro flow. Handoff exports SVG, PNG, JPG and PDF at three scales, or a named region, or a link somebody with no account can open. And the long tail — the pen and vector networks, booleans, masks, text on a path, pattern fills, find and replace, templates, branching and merging, breakout rooms, cursor chat, dot voting, smart animate, plugins behind four walls stated before any of them were written — is sixteen of sixteen rows, on both clients, not a reduced phone version. What is not built is written down rather than left off: there is no import of a Figma file or a .vsdx, widgets are not built, and nothing has yet been opened on a physical device. Cost to build this step: $120.</description>
    </item>
    <item>
      <title>Blueprint: Wave 7 on the phone — all nine rows</title>
      <link>https://tank.chat/#neuralboards-step-26</link>
      <guid isPermaLink="false">neuralboards-26</guid>
      <pubDate>Wed, 07 Oct 2026 00:53:28 GMT</pubDate>
      <category>Blueprint</category>
      <description>The pen and point editing, boolean operations, masks and frame clipping, text on a path, image crop and fit, pattern fills, find and replace, the template gallery, branching a board with a diff, and dot voting with a shared timer — all of it now on iOS and Android, not a reduced view-and-comment version. The rules are the browser's own modules copied across byte for byte and checked that way, so a board drawn on a phone and a board drawn in a browser are the same board. Where a thumb could not do what a mouse does the answer was a different interaction, never a missing feature: the pen places corners by tapping and the point editor curves them, and taking a vote back is a long press because there is no shift key. 1,097 tests, and every difference between the two clients is written down. Cost to build this step: $48.</description>
    </item>
    <item>
      <title>Blueprint: A board that said it had fallen behind a build called &quot;undefined&quot;</title>
      <link>https://tank.chat/#neuralboards-step-25</link>
      <guid isPermaLink="false">neuralboards-25</guid>
      <pubDate>Tue, 06 Oct 2026 23:48:57 GMT</pubDate>
      <category>Blueprint</category>
      <description>A frame records the commit it was drawn from so the board can notice the product has moved past it. Every frame made in the browser was recording the word &quot;undefined&quot; instead: the frame was built as a plain object with three of its thirteen fields left out, and the binary encoder Connect uses writes a missing field as the text &quot;undefined&quot; rather than refusing. Boards then announced they were behind a build called undefin. Fixed in both halves — the browser fills every field, and the server now treats anything that is not a commit as never drawn, so boards already carrying one heal themselves on the next read instead of needing a hand-written fix on production. Cost to build this step: $7.</description>
    </item>
    <item>
      <title>Blueprint: Shapes from a table, on a phone</title>
      <link>https://tank.chat/#neuralboards-step-24</link>
      <guid isPermaLink="false">neuralboards-24</guid>
      <pubDate>Tue, 06 Oct 2026 23:48:50 GMT</pubDate>
      <category>Blueprint</category>
      <description>Paste a CSV or pick one from the Files app and every row becomes a shape — any stencil, laid out in a grid, coloured by rules like &quot;status is blocked → amber&quot;. Each rule says how many rows it catches before you run it, because a rule that catches nothing is almost always a column name typed slightly wrong, and finding that out after fifty shapes have landed is finding it out too late. The parsing, the rules and the layout are the same module the browser uses, so the same table makes the same board on either device. Cost to build this step: $6.</description>
    </item>
    <item>
      <title>Blueprint: The before and the after, side by side</title>
      <link>https://tank.chat/#neuralboards-step-23</link>
      <guid isPermaLink="false">neuralboards-23</guid>
      <pubDate>Tue, 06 Oct 2026 18:32:36 GMT</pubDate>
      <category>Blueprint</category>
      <description>The thing this product exists for now works end to end. Push a branch and it builds its own preview of the whole application, stamped so every element still reports the line that drew it; a frame on a board naming that branch resolves to it; and the current app and the proposed change sit on the same board as two live frames, both running, both clickable. Building it caught a bug that green CI would have hidden forever: the first production deploy after previews landed wiped every preview, because the deploy syncs the bucket with delete and previews are not in the build output — every live frame on every board would have quietly gone dark. And one of mine: a frame pinned to a branch was being compared against main, so shipping main badged it as out of date when it was showing precisely what it was drawn from. A frame is judged against its own branch now. Cost to build this step: $21.</description>
    </item>
    <item>
      <title>Blueprint: Where the build actually is</title>
      <link>https://tank.chat/#neuralboards-step-22</link>
      <guid isPermaLink="false">neuralboards-22</guid>
      <pubDate>Tue, 06 Oct 2026 16:32:54 GMT</pubDate>
      <category>Blueprint</category>
      <description>Both clients have reached Wave 6 of the parity list: the board, the running app in a frame, design systems, diagrams, prototyping with a Play mode, and export. The parity page now carries a table saying exactly that, per wave and per client, and underneath it every gap that is still open — Wave 7 untouched on both, smart animate missing, export still SVG only, a hotspot exporting as the rectangle it is drawn on, no file picker for CSV on the phone, and three Wave 4 rows that are server work nobody has yet. The page is published and will keep being corrected rather than quietly improved: a parity list that flatters the build is worth less than no list. Cost to build this step: $5.</description>
    </item>
    <item>
      <title>Blueprint: A board that tells you, and a prototype that runs</title>
      <link>https://tank.chat/#neuralboards-step-21</link>
      <guid isPermaLink="false">neuralboards-21</guid>
      <pubDate>Tue, 06 Oct 2026 15:40:29 GMT</pubDate>
      <category>Blueprint</category>
      <description>Two pieces, both clients, same change. A board now shows what the server has been working out since this morning: a frame the product has moved past wears a badge, the board carries a sentence saying what shipped since it was drawn, the list tints the rows that need a look, and Refresh this frame redraws it against the build that is live now. And prototyping proper — hotspots on a frame, interactions on tap or after a delay, transitions that dissolve, push or slide with a direction and a duration, named flows, interactive components that swap on a tap, and a Play mode that follows the wiring rather than the order the frames happen to sit in. Roughly 140 new tests across the two apps, most of them the same pure modules running in both. Hover is offered and labelled as a browser's: a prototype that silently does nothing on a phone is worse than one that says so. Cost to build this step: $44.</description>
    </item>
    <item>
      <title>Blueprint: The phone catches the desktop</title>
      <link>https://tank.chat/#neuralboards-step-20</link>
      <guid isPermaLink="false">neuralboards-20</guid>
      <pubDate>Tue, 06 Oct 2026 13:54:32 GMT</pubDate>
      <category>Blueprint</category>
      <description>Mobile is level with the web: live app frames, picking an element and asking for a change, tokens, components, styles, auto layout, constraints, layers, groups, connectors, five stencil sets, containers, trees, export through the share sheet, flows that write tests, templates and present mode. Nine builds, every one green, all on TestFlight. Roughly 250 of its 456 board tests are the web's own tests running unmodified on the phone, because every rule was written as a pure module to be reused rather than rewritten. Where a finger cannot do what a mouse does, the answer was a different gesture rather than a missing feature: the interacting and picking toggles became one three-way control, because the first thing a thumb does is the thing; a connector is two taps, since you cannot hover over the second shape while holding the first; and components and stencils are placed in the middle of the view rather than dragged out of a scrolling list. Cost to build this step: $42.</description>
    </item>
    <item>
      <title>Blueprint: A diagram that is still a diagram when it leaves</title>
      <link>https://tank.chat/#neuralboards-step-19</link>
      <guid isPermaLink="false">neuralboards-19</guid>
      <pubDate>Tue, 06 Oct 2026 12:05:10 GMT</pubDate>
      <category>Blueprint</category>
      <description>A connector's shape is never stored — it is derived from the two boxes it joins — so the exporter had been drawing every diagram as straight lines through the middle of its own shapes, and silhouettes as plain rectangles. The editor's routing is ported to the server now: the same choice of facing sides, the same stubs and elbows, the same waypoints, and each end drawing what it was given rather than an arrow for everything. Diamonds, parallelograms, hexagons, documents and cylinders are real paths. A flowchart sent to somebody without a TANK account arrives as a flowchart. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Blueprint: Diagrams, flows that write tests, and a board that presents</title>
      <link>https://tank.chat/#neuralboards-step-18</link>
      <guid isPermaLink="false">neuralboards-18</guid>
      <pubDate>Tue, 06 Oct 2026 12:05:04 GMT</pubDate>
      <category>Blueprint</category>
      <description>Waves 4, 5 and 6 on the web. Connectors that are worked out from the two shapes they join every time they are drawn, so they stay right when things move: orthogonal or straight, leaving an edge rather than a centre, waypoints you can drag, a label on the line, and proper ends including a crow's foot. Five stencil sets — flowchart, UML, ERD, BPMN and a generic network one, with no vendor icon art. Containers and swimlanes that grow to hold what is dropped in them. Mind maps and org charts that lay themselves out after every edit. A CSV becomes a shape per row with rules that colour them, each rule showing how many rows it will touch before it runs. Click through a journey in a live frame and get a Playwright spec and a Maestro flow. Export the board, or a selection, as a file. Present it full screen with the running app still running inside it. 449 board tests, 726 across the app. Cost to build this step: $46.</description>
    </item>
    <item>
      <title>Blueprint: A board that admits when it has gone out of date</title>
      <link>https://tank.chat/#neuralboards-step-17</link>
      <guid isPermaLink="false">neuralboards-17</guid>
      <pubDate>Tue, 06 Oct 2026 11:16:11 GMT</pubDate>
      <category>Blueprint</category>
      <description>The oldest failure in design tooling, and the reason this product exists: a file drawn against an application in March, still being shown to people in October, with nobody able to say which parts of it are still true. A frame now records the commit it was drawn against, and opening the board checks that against what is actually deployed — naming the frame, the build it saw, and the build that is running. It is deliberately quiet: a board is not stale because a day passed or because somebody drew a rectangle, only because the thing it is a picture of changed underneath it. A frame with no recorded build has no history to be stale against and is left alone, and redrawing a frame is how you say this is true again. The board list carries it too, so a stale board can be found without opening every board to look. Cost to build this step: $12.</description>
    </item>
    <item>
      <title>Blueprint: The agent is in the board, and the board is whole</title>
      <link>https://tank.chat/#neuralboards-step-16</link>
      <guid isPermaLink="false">neuralboards-16</guid>
      <pubDate>Tue, 06 Oct 2026 10:46:35 GMT</pubDate>
      <category>Blueprint</category>
      <description>Deployed together. The workspace agent can now read a board as something it can reason about, draw on it, and tidy it into rows, columns or a grid — and while it works its cursor moves across the board in its own colour, so shapes do not simply appear from nowhere. Alongside it, three things the clients had been working around: a board made without a Tread could never ask for a change and had no way out of that, so it can be moved into one; the editor's relationships — instances, styles, layout, constraints — had been riding inside a connector's field for want of anywhere to live, and now have a field of their own; and shapes can carry a shadow and a blur, which the exporter renders with one filter definition per distinct look rather than one per shape. Cost to build this step: $14.</description>
    </item>
    <item>
      <title>Blueprint: Components, styles and layout that lay themselves out</title>
      <link>https://tank.chat/#neuralboards-step-15</link>
      <guid isPermaLink="false">neuralboards-15</guid>
      <pubDate>Tue, 06 Oct 2026 07:40:27 GMT</pubDate>
      <category>Blueprint</category>
      <description>Wave 3. A component is a named thing you place many times, and an instance follows it when it changes — except where you have overridden something, which is worked out rather than recorded. Named styles resolve the same way. A frame can lay its children out: direction, gap, padding, alignment and wrap, hugging or filling, innermost first so a nested frame sizes before the one around it measures it. Constraints pin a child to edges or centre when its parent resizes. Groups, a layers panel you can drag, rename, hide and lock in, copy and paste across boards, rotation and images all landed with it. The colour picker now names the brand: a swatch says Agent purple, and a colour that is nearly a brand colour offers to become one. 153 new tests, 527 in the repo. Two genuine bugs fell out of driving a real browser: an object created in the same breath as its parent pointed at an id the server had already replaced, and a component holding a group arrived empty. Cost to build this step: $38.</description>
    </item>
    <item>
      <title>Blueprint: The board on a phone, with nothing taken out</title>
      <link>https://tank.chat/#neuralboards-step-14</link>
      <guid isPermaLink="false">neuralboards-14</guid>
      <pubDate>Tue, 06 Oct 2026 06:29:02 GMT</pubDate>
      <category>Blueprint</category>
      <description>Full parity, not a viewer. Place frames, rectangles, ellipses, lines, arrows, text, sticky notes and freehand; tap, long-press or lasso to select; drag to move with snapping and amber guides; a corner handle resizes a whole selection, the handle above it rotates, and a line's endpoints have their own. Duplicate, delete, paint order, align on six edges, distribute on two axes, undo and redo. The inspector is the whole set — fill, stroke, weight, dash, radius, opacity, type size and weight, alignment, width, height, rotation, lock — and text is typed on the canvas itself at its real size and colour, not in a modal. Objects save one at a time carrying their revisions, undo included, so a collision on a phone shows both versions the same way it does on a desktop. 138 board tests, 459 in the repo. On TestFlight now. Cost to build this step: $27.</description>
    </item>
    <item>
      <title>Blueprint: The frame holds the real app, and clicking it finds the code</title>
      <link>https://tank.chat/#neuralboards-step-13</link>
      <guid isPermaLink="false">neuralboards-13</guid>
      <pubDate>Tue, 06 Oct 2026 06:26:16 GMT</pubDate>
      <category>Blueprint</category>
      <description>Wave 2, working. A frame on the board now renders the running application in it — the actual product, not a picture — and while you are interacting the clicks go to the app the way a user's would. Switch to picking and a click is caught instead of performed, so pressing Delete inside the embedded app inspects that button rather than deleting anything real. The element comes back with its tag, its words, its test id, and the file and line that drew it; say what should change and it becomes a thread with the agent, carrying all of that. Building it exposed a flaw in the stamping: only plain HTML tags were marked, and this app has 267 of those against 3,112 components, so 92 percent of what anyone can click resolved to nothing. Components are stamped now — 115 marks became 3,012, and clicking the sidebar resolves to Navigation.tsx line 518. The whole mocked browser suite was re-run with stamping on to prove it changes nothing else; the bundle grew 2.6 percent. Cost to build this step: $31.</description>
    </item>
    <item>
      <title>Blueprint: This is what it looks like</title>
      <link>https://tank.chat/#neuralboards-step-12</link>
      <guid isPermaLink="false">neuralboards-12</guid>
      <pubDate>Tue, 06 Oct 2026 05:56:51 GMT</pubDate>
      <category>Blueprint</category>
      <description>The board, running. A frame bound to the web application saying honestly that its preview is not up yet rather than pretending; a sticky note arguing with it; an arrow that follows the shapes it joins; a rectangle selected with its handles and its size; and an inspector down the side for fill, stroke, radius, opacity and order. Dark, on the brand's own palette, where picking a colour records the token rather than the number. Everything on it saves one object at a time, so the person at the other end of the board is not an obstacle. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Blueprint: A colour picker that picks a decision, not a number</title>
      <link>https://tank.chat/#neuralboards-step-11</link>
      <guid isPermaLink="false">neuralboards-11</guid>
      <pubDate>Tue, 06 Oct 2026 05:52:41 GMT</pubDate>
      <category>Blueprint</category>
      <description>Wave 3 groundwork. On this board the colour picker is not a colour picker: choosing Agent purple records the token, not the hex that token happens to be today. A board that stored a raw colour could never be told the brand had moved; one that stored the token can, which is what makes design tokens being the real tokens possible at all. Every swatch carries the name it came from and what it is for, a second function recognises a raw colour that came from the brand so a shape drawn before tokens existed can be adopted back rather than left behind, and every swatch's text colour is asserted readable on its own fill — a sticky note nobody can read is not a sticky note. Cost to build this step: $5.</description>
    </item>
    <item>
      <title>Blueprint: Templates, export and generated tests are live</title>
      <link>https://tank.chat/#neuralboards-step-10</link>
      <guid isPermaLink="false">neuralboards-10</guid>
      <pubDate>Tue, 06 Oct 2026 05:50:42 GMT</pubDate>
      <category>Blueprint</category>
      <description>Three pieces reached production together. Seven ways to start a board instead of a blank canvas, including two frames holding the real product side by side. Export as SVG, so a board goes to somebody who has never heard of TANK — and a frame holding a live app exports as its outline and the app's name, deliberately not as a snapshot, because a picture of a running app stops being true the moment it is taken. And a journey clicked through a frame now emits a Playwright spec and a Maestro flow, refusing to write any selector a person would not have written by hand: a step with nothing durable to find it by is skipped and reported with what would fix it, because a suite full of brittle selectors teaches everyone to ignore it. All six board methods verified answering on production. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Blueprint: The board, on the web</title>
      <link>https://tank.chat/#neuralboards-step-9</link>
      <guid isPermaLink="false">neuralboards-9</guid>
      <pubDate>Tue, 06 Oct 2026 05:35:14 GMT</pubDate>
      <category>Blueprint</category>
      <description>Wave 1's client. An infinite canvas with pan, zoom, fit and zoom-to-selection; tools for frames, rectangles, ellipses, lines, arrows, text, sticky notes and freehand, each on a keyboard shortcut; click, shift-click and marquee selection; move, eight-handle resize, duplicate, delete, z-order, align and distribute, snapping with guides, and undo. An inspector for fill, stroke, radius, opacity and type. Every object saves on its own carrying the revision it was read at, so two people on one board do not fight, and a collision shows both versions with keep-mine or take-theirs. Other people's cursors move across it live, and an agent's is drawn in its own colour. 86 new tests, and a browser run that caught a real defect: a guard meant to stop writes after a page closes was only ever cleared, never set, so in a development build the editor believed it had been closed and dropped its own saves. The same bug was sitting in Neuralcanvas; it is fixed in both. Cost to build this step: $24.</description>
    </item>
    <item>
      <title>Blueprint: No mobile carve-out</title>
      <link>https://tank.chat/#neuralboards-step-8</link>
      <guid isPermaLink="false">neuralboards-8</guid>
      <pubDate>Tue, 06 Oct 2026 05:31:23 GMT</pubDate>
      <category>Blueprint</category>
      <description>A decision worth writing down before it gets quietly broken: every wave of this ships on the phone as well as the browser. Not a reduced view-and-comment version — vector path editing, auto-layout authoring and the full inspector all land on mobile too. Where a gesture genuinely cannot carry a desktop interaction, the answer is a different interaction that does the same job, not a missing feature. Anything that turns out to be impossible goes on the plan as a named gap rather than being left out and discovered later. It is in the parity list now, at the top, where nobody can miss it. Cost to build this step: $3.</description>
    </item>
    <item>
      <title>Blueprint: A board you can send to somebody without an account</title>
      <link>https://tank.chat/#neuralboards-step-7</link>
      <guid isPermaLink="false">neuralboards-7</guid>
      <pubDate>Tue, 06 Oct 2026 05:25:21 GMT</pubDate>
      <category>Blueprint</category>
      <description>Export, as SVG rather than a picture: a board is vectors already, it stays sharp in a slide deck, and it needs no headless browser on the server. Shapes, sticky notes with wrapped text, freehand paths, and connectors that find their endpoints and draw the arrowhead. Export a selection and you get only that; export transparent and there is no background plate. A frame holding the running application exports as its outline and the name of the app inside it, deliberately not as a snapshot — a picture of a live app stops being true the moment it is taken, which is the thing this whole product argues against. Tested by parsing the result as XML, because the one thing an export must never be is broken markup in somebody's inbox. Cost to build this step: $7.</description>
    </item>
    <item>
      <title>Blueprint: Seven ways to start that are not a blank canvas</title>
      <link>https://tank.chat/#neuralboards-step-6</link>
      <guid isPermaLink="false">neuralboards-6</guid>
      <pubDate>Tue, 06 Oct 2026 05:21:01 GMT</pubDate>
      <category>Blueprint</category>
      <description>Lucid and FigJam are both used mostly through their template galleries, and the honest reason is that a flowchart which already has three boxes and two arrows tells you what the tool is for. Flowchart, architecture, user journey, wireframe, retro and brainstorm, all deliberately small — a shape to start from rather than an artefact to dismantle. And one that only this product can offer: The running app, two frames holding the real thing, web beside phone, with a note saying to click anything in either and say what should change. Every template is tested by building a board from it and checking it holds together: every object has an id and a kind, and no arrow points at a shape that is not there. Cost to build this step: $6.</description>
    </item>
    <item>
      <title>Blueprint: Point at a button, say what is wrong, and it becomes work</title>
      <link>https://tank.chat/#neuralboards-step-5</link>
      <guid isPermaLink="false">neuralboards-5</guid>
      <pubDate>Tue, 06 Oct 2026 05:16:36 GMT</pubDate>
      <category>Blueprint</category>
      <description>The loop the product exists for, end to end on the server. Click an element inside a running frame, say what should change, and it becomes a thread in the Tread the board belongs to, addressed to the workspace's agent and carrying the one thing nobody could have typed by hand: the file and line the preview build stamped on that element, the tag, what it reads, and its test id. From there it is an ordinary TANK run — a plan, a gate somebody approves, a branch, CI, a deploy — because the board should be a better way to start that conversation, not a second pipeline beside it. The thread it opens is where the plan and the cards appear. Cost to build this step: $11.</description>
    </item>
    <item>
      <title>Blueprint: A frame points at the app that is actually running</title>
      <link>https://tank.chat/#neuralboards-step-4</link>
      <guid isPermaLink="false">neuralboards-4</guid>
      <pubDate>Tue, 06 Oct 2026 05:12:40 GMT</pubDate>
      <category>Blueprint</category>
      <description>Wave 2 begins. A frame on a board names a repo, a branch and a route; the server turns that into a URL a browser can load, and tells the truth when it cannot. The deployed branch resolves to the real product, flagged so the app knows it is embedded in a board. A feature branch nobody has built, a repository TANK does not publish, or a web build asked to stand in for an iOS frame each come back with a sentence saying why — because a frame quietly showing the wrong commit is worse than a frame showing nothing. Six cases, six tests. Cost to build this step: $8.</description>
    </item>
    <item>
      <title>Blueprint: The board exists, and the clock tells the truth</title>
      <link>https://tank.chat/#neuralboards-step-3</link>
      <guid isPermaLink="false">neuralboards-3</guid>
      <pubDate>Tue, 06 Oct 2026 04:42:01 GMT</pubDate>
      <category>Blueprint</category>
      <description>Wave 1 on the server: boards hold frames, shapes, text, sticky notes, images, connectors and freehand, and a frame can name a repo, a branch and a route — the thing that separates this from every other canvas. Writes are per object with a revision each, so two people dragging different shapes never meet, and the same shape moved twice comes back with the other person's version and their name rather than one of them silently winning. Deleting a frame takes what is inside it. The gateway carries board subscriptions and a pointer frame, so a board can show the people, and the agent, moving around it. Also fixed: the clock on this page counted wall time, so four hours with nobody at the keyboard read as four hours of building. It now counts time actually spent building, pausing after 45 minutes of silence. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Blueprint: Click a button, find the line that drew it</title>
      <link>https://tank.chat/#neuralboards-step-2</link>
      <guid isPermaLink="false">neuralboards-2</guid>
      <pubDate>Tue, 06 Oct 2026 00:01:25 GMT</pubDate>
      <category>Blueprint</category>
      <description>The hinge the whole product turns on, built first because nothing else works without it. A board holds the running application in a frame; somebody clicks a button inside it; the agent has to know which file and line drew that button before it can change anything. React 19 removed the debug information from its internals and devtools inspection does not survive a build, so the answer is an attribute that is simply part of the page: data-tank-src=&quot;src/features/shell/Logo.tsx:8:5&quot;. A compiler plugin stamps every real element and leaves components alone, because a component's tag never reaches the page. Verified against a real build of TANK's own web app: line 8 is the svg, line 15 is the rect, and a card's span is where it says it is. Four tests hold it there. Cost to build this step: $7.</description>
    </item>
    <item>
      <title>Blueprint: The list, before the code</title>
      <link>https://tank.chat/#neuralboards-step-1</link>
      <guid isPermaLink="false">neuralboards-1</guid>
      <pubDate>Tue, 06 Oct 2026 00:01:18 GMT</pubDate>
      <category>Blueprint</category>
      <description>Neuralboards takes on Figma and Lucid together: an infinite board where a frame holds the running application rather than a picture of one. Before writing any of it, the full parity list is published — every feature Figma, FigJam, Lucidchart and Lucidspark have, grouped into seven waves, with the ten things only this product can do and the hard parts named up front. Honest about scale: the last two products were an afternoon each because a ledger and a block document are well-understood shapes. A design tool is not. The list is complete, the build is a program, and this log will show exactly how far along it is rather than claiming a finish that has not happened. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Atlas: Decisions are rows, not text</title>
      <link>https://tank.chat/#neuralcanvas-step-14</link>
      <guid isPermaLink="false">neuralcanvas-14</guid>
      <pubDate>Mon, 05 Oct 2026 18:38:13 GMT</pubDate>
      <category>Atlas</category>
      <description>Asking whether a decision had been replaced used to be a text search across every page in the workspace, and asking what the team had decided had no answer at all. Every page write now projects its decision blocks into a table in the same transaction: the page stays the source of truth, the table is how the workspace is asked. A page resting on a replaced decision is told what replaced it, by name. Decisions written before the ledger existed were backfilled, so nothing has to be re-saved by hand. Verified on production: the ledger holds both decisions that were already on pages. Cost to build this step: $13.</description>
    </item>
    <item>
      <title>Atlas: Two people, one page, nothing lost</title>
      <link>https://tank.chat/#neuralcanvas-step-13</link>
      <guid isPermaLink="false">neuralcanvas-13</guid>
      <pubDate>Mon, 05 Oct 2026 18:19:23 GMT</pubDate>
      <category>Atlas</category>
      <description>Every line carries the revision it was read at. Two people writing different paragraphs never collide at all. The same line, twice, comes back with both versions and a choice: keep mine, take theirs. Nothing is overwritten and nothing is thrown away. A page shows who else is in it and which line they are on. Writing the tests found a real defect in our own editor: saving a line gave the line below it a new identity, which threw the caret out of whatever was being typed. Cost to build this step: $14.</description>
    </item>
    <item>
      <title>Atlas: The same writing on a phone</title>
      <link>https://tank.chat/#neuralcanvas-step-12</link>
      <guid isPermaLink="false">neuralcanvas-12</guid>
      <pubDate>Mon, 05 Oct 2026 18:19:17 GMT</pubDate>
      <category>Atlas</category>
      <description>Parity, with the parts that only make sense on a phone changed. The marks matter more here than on a desktop, where the alternative is hunting for a control with a thumb. A newline ends the line and opens the next one; arrows move a line. Mobile had been read-only, which broke our own rule that every feature ships on both. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Atlas: A page you can actually write in</title>
      <link>https://tank.chat/#neuralcanvas-step-11</link>
      <guid isPermaLink="false">neuralcanvas-11</guid>
      <pubDate>Mon, 05 Oct 2026 18:19:11 GMT</pubDate>
      <category>Atlas</category>
      <description>The editor was a dropdown and a text box per block, which is the wrong shape for the thing this product is about. Now it is a document. Typing a mark makes the line: # a heading, - a bullet, [] a to do, &gt; a quote, three backticks code. Enter opens the next line and carries a list on. Backspace on an empty line takes it out. Slash offers the blocks that have no mark, narrowing as you type. Headings look like headings while you are typing them, not after you save. Cost to build this step: $11.</description>
    </item>
    <item>
      <title>Atlas: Two people can write on the same page</title>
      <link>https://tank.chat/#neuralcanvas-step-10</link>
      <guid isPermaLink="false">neuralcanvas-10</guid>
      <pubDate>Mon, 05 Oct 2026 16:41:01 GMT</pubDate>
      <category>Atlas</category>
      <description>Saving a whole page makes an edit a conflict: whoever saves second is told to reload, which is absurd when they were writing in different paragraphs. Editing a block now leaves the rest of the page alone, so two people writing in different places both succeed and both paragraphs survive. Only the same block edited at the same moment has a last writer, which is a far smaller thing to lose than a page. Cost to build this step: $5.</description>
    </item>
    <item>
      <title>Atlas: The Vault really does read the pages now</title>
      <link>https://tank.chat/#neuralcanvas-step-9</link>
      <guid isPermaLink="false">neuralcanvas-9</guid>
      <pubDate>Mon, 05 Oct 2026 16:40:56 GMT</pubDate>
      <category>Atlas</category>
      <description>The homepage claimed the Neural Vault reads your pages. Until now that was Postgres matching words, which is not the same thing, so it has been built. Every block that carries readable text is embedded on its own, which means an answer points at the passage rather than the page, and asking about &quot;refunds&quot; finds the decision that only ever says &quot;give the money back&quot;. Every answer now says how it was found: by words, by meaning, or by both. And when the Vault cannot be reached the reply admits it is words only rather than implying the pages were understood. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Atlas: The agent writes the page</title>
      <link>https://tank.chat/#neuralcanvas-step-8</link>
      <guid isPermaLink="false">neuralcanvas-8</guid>
      <pubDate>Mon, 05 Oct 2026 16:05:49 GMT</pubDate>
      <category>Atlas</category>
      <description>The last piece of the idea: say &quot;write this up&quot; in a thread and the agent turns the conversation into a page, with what was settled as decision blocks, the messages kept underneath so the summary can be checked against what was actually said, and the thread cited as its source. Which means the page it just wrote will tell you, next month, that the conversation moved past it. The agent also asks the pages before asking a person, and before settling something the team may already have settled. Live on the control plane and in the agent image. Cost to build this step: $6.</description>
    </item>
    <item>
      <title>Atlas: Follow it as it happens</title>
      <link>https://tank.chat/#neuralcanvas-step-7</link>
      <guid isPermaLink="false">neuralcanvas-7</guid>
      <pubDate>Mon, 05 Oct 2026 15:52:56 GMT</pubDate>
      <category>Atlas</category>
      <description>Nobody watched the last build because it finished before anyone knew it had started. So this one has the plumbing for an audience: a feed at tank.chat/builds.xml carrying every step of every product built in the open, and a permalink on each step so one of them can be shared on its own rather than a link to the whole page. Cost to build this step: $3.</description>
    </item>
    <item>
      <title>Atlas: Neuralcanvas on the phone</title>
      <link>https://tank.chat/#neuralcanvas-step-6</link>
      <guid isPermaLink="false">neuralcanvas-6</guid>
      <pubDate>Mon, 05 Oct 2026 15:45:20 GMT</pubDate>
      <category>Atlas</category>
      <description>The same pages in your hand: which have fallen behind and why, the decisions and live figures rendered, and a question answered with the passage. Editing stays on the web; knowing whether to trust what you are reading is what you need on a phone. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Atlas: Proof: a page reading the other product</title>
      <link>https://tank.chat/#neuralcanvas-step-5</link>
      <guid isPermaLink="false">neuralcanvas-5</guid>
      <pubDate>Mon, 05 Oct 2026 15:42:12 GMT</pubDate>
      <category>Atlas</category>
      <description>A page created on the running product, with a decision block and a live figure set to &quot;owed to us&quot;. It came back reading $1,770.00 across one open invoice: the real number, out of Neuralbooks, on a Neuralcanvas page, in the same workspace. That is the thing a screenshot pasted into a wiki can never do, and it is why the two products are worth building in the same place. Asking &quot;how often do we chase unpaid invoices&quot; answered with the decision. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Atlas: Neuralcanvas on the web</title>
      <link>https://tank.chat/#neuralcanvas-step-4</link>
      <guid isPermaLink="false">neuralcanvas-4</guid>
      <pubDate>Mon, 05 Oct 2026 15:33:09 GMT</pubDate>
      <category>Atlas</category>
      <description>Pages, with what each one rests on and whether it still holds. A page that has fallen behind says so at the top in a sentence naming what moved, and the list leads with those. Decisions render as decisions rather than paragraphs. A live block shows the figure read the moment the page opened. Asking a question returns the passage that answers it, above the pages it came from. Cost to build this step: $5.</description>
    </item>
    <item>
      <title>Atlas: Search that does not demand every word</title>
      <link>https://tank.chat/#neuralcanvas-step-3</link>
      <guid isPermaLink="false">neuralcanvas-3</guid>
      <pubDate>Mon, 05 Oct 2026 15:25:54 GMT</pubDate>
      <category>Atlas</category>
      <description>Writing the test for asking a question caught a real defect, and it is the exact thing people hate about wiki search. Asking &quot;how often do we chase unpaid invoices&quot; skipped the page recording &quot;unpaid invoices are chased every seven days&quot;, because the page lacked the word &quot;often&quot;. Matching now takes any term and the ranking is done by the passage that actually answers, with a recorded decision beating a paragraph that merely mentions the subject. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Atlas: A page that knows what it rests on</title>
      <link>https://tank.chat/#neuralcanvas-step-2</link>
      <guid isPermaLink="false">neuralcanvas-2</guid>
      <pubDate>Mon, 05 Oct 2026 15:25:50 GMT</pubDate>
      <category>Atlas</category>
      <description>The core of Neuralcanvas is written and proven against a database. A canvas is blocks on a page, but it also records what it was written from: the threads it came out of, the pages it leans on, the decisions it assumes. Reading it re-checks them and says in a sentence what has moved. Decisions are blocks rather than paragraphs, so what a team settled stays answerable. A live block holds what to look up instead of a figure, so it cannot go out of date, and a client cannot write one in. Two people editing is fine; a save over somebody else's is refused with what to do about it. Cost to build this step: $11.</description>
    </item>
    <item>
      <title>Atlas: Neuralcanvas begins</title>
      <link>https://tank.chat/#neuralcanvas-step-1</link>
      <guid isPermaLink="false">neuralcanvas-1</guid>
      <pubDate>Mon, 05 Oct 2026 15:10:25 GMT</pubDate>
      <category>Atlas</category>
      <description>The board picked the target again: Notion carries the highest exposure on TANK's own research, with more recorded complaints than any other horizontal tool. So the second product built in the open is the written side of a team's work. The difference is one idea: a page remembers what it was written from, and tells you when that has moved. A wiki nobody trusts is a wiki nobody reads. The public contract is written and the clock starts now. Cost to build this step: $7.</description>
    </item>
    <item>
      <title>Books: Proof: a receipt read on the real thing</title>
      <link>https://tank.chat/#neuralbooks-step-20</link>
      <guid isPermaLink="false">neuralbooks-20</guid>
      <pubDate>Mon, 05 Oct 2026 13:42:54 GMT</pubDate>
      <category>Books</category>
      <description>A photograph of a hardware store receipt, uploaded to a live workspace and read by the running product: Northside Hardware, $139.33, filed under supplies, dated 10 March, 95 percent sure. Nothing hand-fed, nothing mocked. That is the whole loop a tradesperson does twenty times a month, done by pointing a phone at a bit of paper. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Books: Hand the year to an accountant</title>
      <link>https://tank.chat/#neuralbooks-step-19</link>
      <guid isPermaLink="false">neuralbooks-19</guid>
      <pubDate>Mon, 05 Oct 2026 13:15:12 GMT</pubDate>
      <category>Books</category>
      <description>Invoices, expenses or the whole journal as a CSV an accountant opens without asking what TANK is, in decimal rather than cents, over any period. The journal export balances, because it is the same journal the books are kept in rather than a second count of the same money. Cost to build this step: $3.</description>
    </item>
    <item>
      <title>Books: A prediction that pools what everyone knows</title>
      <link>https://tank.chat/#neuralbooks-step-18</link>
      <guid isPermaLink="false">neuralbooks-18</guid>
      <pubDate>Mon, 05 Oct 2026 13:15:06 GMT</pubDate>
      <category>Books</category>
      <description>Guessing when an invoice will be paid is hardest for the business that just started: a new customer has paid nothing. So the estimate is pooled. Each customer's own lateness is pulled toward how late this business's customers pay, and that toward how late everyone on TANK pays, each weighted by how much evidence stands behind it. One late invoice from a new customer barely moves the answer; twenty move it almost entirely. Larger invoices are expected later where a business's own history says so. It gets better for everybody as the platform fills up, and it says plainly when it does not know. Cost to build this step: $7.</description>
    </item>
    <item>
      <title>Books: Photograph a receipt and the expense fills itself in</title>
      <link>https://tank.chat/#neuralbooks-step-17</link>
      <guid isPermaLink="false">neuralbooks-17</guid>
      <pubDate>Mon, 05 Oct 2026 13:14:57 GMT</pubDate>
      <category>Books</category>
      <description>Point a phone at a receipt, or drop a photo on the web, and the model reads the vendor, the amount, the date and a category straight into the form, with how sure it is and a sentence about anything it could not make out. It books nothing on its own: a person or the agent still confirms. A receipt it cannot read says so and asks you to type it. Cost to build this step: $6.</description>
    </item>
    <item>
      <title>Books: Customers can pay by card, and the money is never ours</title>
      <link>https://tank.chat/#neuralbooks-step-16</link>
      <guid isPermaLink="false">neuralbooks-16</guid>
      <pubDate>Mon, 05 Oct 2026 13:14:51 GMT</pubDate>
      <category>Books</category>
      <description>A business pastes its own Stripe key and every invoice it sends carries a card link. The money lands in the business's account; TANK is never in the flow and never holds it. The key is sealed before it is stored and only ever shown back as its last four characters, so a copy of the database cannot charge anyone. Payments are picked up by asking Stripe which checkout sessions were paid rather than by hosting a webhook, so connecting payments is one pasted key and nothing else. Stripe being slow never stops an invoice going out. Cost to build this step: $9.</description>
    </item>
    <item>
      <title>Books: Minutes on the clock, and the log reads cleanly</title>
      <link>https://tank.chat/#neuralbooks-step-15</link>
      <guid isPermaLink="false">neuralbooks-15</guid>
      <pubDate>Mon, 05 Oct 2026 12:08:29 GMT</pubDate>
      <category>Books</category>
      <description>The counters now say hours and minutes, not just hours, and every step's line carries its time, how far into the build it landed and what it cost, separated rather than run together. The log entries are rebuilt in the browser on every refresh, which was quietly stripping their styling a few seconds after the page loaded; their rules are global now, so what you see at the start is what you see an hour in. Cost to build this step: $2.</description>
    </item>
    <item>
      <title>Books: Money the way people say it</title>
      <link>https://tank.chat/#neuralbooks-step-14</link>
      <guid isPermaLink="false">neuralbooks-14</guid>
      <pubDate>Mon, 05 Oct 2026 11:49:43 GMT</pubDate>
      <category>Books</category>
      <description>A business that has paid out before being paid in is not holding a negative balance, it is out of pocket. The report now says so. Small, but this is the whole point of Neuralbooks: double entry underneath, sentences on top. Cost to build this step: $1.</description>
    </item>
    <item>
      <title>Books: The agent can read the books out loud</title>
      <link>https://tank.chat/#neuralbooks-step-13</link>
      <guid isPermaLink="false">neuralbooks-13</guid>
      <pubDate>Mon, 05 Oct 2026 11:49:39 GMT</pubDate>
      <category>Books</category>
      <description>Ask the agent in a thread how the quarter went and it answers from the same report: invoiced, spent, made, in hand, owed, with the biggest costs and the customers behind the revenue. It never recomputes the numbers; it relays what the journal says. Live on the control plane and in the agent image now. Cost to build this step: $3.</description>
    </item>
    <item>
      <title>Books: Reports that answer the question</title>
      <link>https://tank.chat/#neuralbooks-step-12</link>
      <guid isPermaLink="false">neuralbooks-12</guid>
      <pubDate>Mon, 05 Oct 2026 11:27:48 GMT</pubDate>
      <category>Books</category>
      <description>Ask how the month went and Neuralbooks answers in a sentence: what you invoiced, what you spent, what you made, what is in hand and what is still owed, with the biggest costs and the customers behind the revenue. Every figure is read from the same double-entry journal the books are kept in, so the report and the ledger can never disagree. On the web, on the phone, and in the agent's hands. Cost to build this step: $5.</description>
    </item>
    <item>
      <title>Books: The bank feed, and reconciliation that says why</title>
      <link>https://tank.chat/#neuralbooks-step-11</link>
      <guid isPermaLink="false">neuralbooks-11</guid>
      <pubDate>Mon, 05 Oct 2026 11:23:45 GMT</pubDate>
      <category>Books</category>
      <description>A statement comes in as a file. Every line is matched to an invoice or an expense, or offered as a new one, and each suggestion says why in a sentence: the line names the invoice, the amount equals what is still owed, an expense for the same amount was booked within three days. A line that names an invoice and pays its balance exactly is matched on the spot; the rest wait for one tap. Importing the same file twice changes nothing. Cost to build this step: $6.</description>
    </item>
    <item>
      <title>Books: Try it: a real invoice, as the customer sees it</title>
      <link>https://tank.chat/#neuralbooks-step-10</link>
      <guid isPermaLink="false">neuralbooks-10</guid>
      <pubDate>Mon, 05 Oct 2026 10:22:08 GMT</pubDate>
      <category>Books</category>
      <description>The first invoice from a demo business on Neuralbooks, open to anyone with the link: the lines, the total, what is still due, and how to pay. No account, no app. This is what a customer of a business on TANK receives when the agent sends an invoice from a thread. Cost to build this step: $1.</description>
    </item>
    <item>
      <title>Books: Unpaid money on Home, web and phone</title>
      <link>https://tank.chat/#neuralbooks-step-9</link>
      <guid isPermaLink="false">neuralbooks-9</guid>
      <pubDate>Mon, 05 Oct 2026 10:21:44 GMT</pubDate>
      <category>Books</category>
      <description>Home now carries one line when Neuralbooks is on: what you are owed and how much of it is overdue, with the way to the page. Unpaid money should not need a report to be seen. Live on the web and in the app store build that just landed. Cost to build this step: $2.</description>
    </item>
    <item>
      <title>Books: Sent means sent, and the agent chases</title>
      <link>https://tank.chat/#neuralbooks-step-8</link>
      <guid isPermaLink="false">neuralbooks-8</guid>
      <pubDate>Mon, 05 Oct 2026 09:53:20 GMT</pubDate>
      <category>Books</category>
      <description>Sending an invoice now mints a link the customer opens without an account: the lines, the total, what is still due, and how to pay, from the business's own payment instructions. And every hour the agent looks for invoices past due; on the cadence the workspace sets it says so in the thread the invoice was asked for in, with what is owed and what to do next, and never twice in one cadence. Cost to build this step: $5.</description>
    </item>
    <item>
      <title>Books: The agent can keep the books</title>
      <link>https://tank.chat/#neuralbooks-step-7</link>
      <guid isPermaLink="false">neuralbooks-7</guid>
      <pubDate>Mon, 05 Oct 2026 09:48:20 GMT</pubDate>
      <category>Books</category>
      <description>The agent now has Neuralbooks in its hands: it can read what the workspace is owed and what is overdue, write and send an invoice for a customer by name, book an expense from a receipt dropped in the thread, and record a payment against an invoice number. Every call reaches the books as the workspace's own agent, with the same checks a person gets, so a run can do exactly what its workspace allows. Rolling out to the control plane and the agent image now. Cost to build this step: $6.</description>
    </item>
    <item>
      <title>Books: Neuralbooks on the phone</title>
      <link>https://tank.chat/#neuralbooks-step-6</link>
      <guid isPermaLink="false">neuralbooks-6</guid>
      <pubDate>Mon, 05 Oct 2026 09:43:53 GMT</pubDate>
      <category>Books</category>
      <description>The same page, on iOS and Android: what is owed, what is overdue, what came in and went out, what the model expects, and the invoices, customers and expenses behind it, with new invoices, expenses and payments from the phone. It sits in the workspace drawer next to Agent runs. Going through the app store build now. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Books: Cost on every step</title>
      <link>https://tank.chat/#neuralbooks-step-5</link>
      <guid isPermaLink="false">neuralbooks-5</guid>
      <pubDate>Mon, 05 Oct 2026 09:40:13 GMT</pubDate>
      <category>Books</category>
      <description>Every step now carries what it cost to build, worked out the way TANK meters an agent run: the tokens read and written, at TANK's rate table, plus any TANK agent minutes from the ledger. The running total is the counter above, and the method is published beside it. Cost to build this step: $2.</description>
    </item>
    <item>
      <title>Books: Neuralbooks in the workspace, on the web</title>
      <link>https://tank.chat/#neuralbooks-step-4</link>
      <guid isPermaLink="false">neuralbooks-4</guid>
      <pubDate>Mon, 05 Oct 2026 09:40:12 GMT</pubDate>
      <category>Books</category>
      <description>Neuralbooks has its own entry in the TANK navigation. The page shows what is owed, what is overdue, what came in and went out in the last thirty days, and what the model expects to arrive in thirty days and six weeks, with the invoices, customers and expenses behind the numbers. New invoices and expenses from a dialog, payments recorded on the row, drafts sent with one click. Off, it says what it is and lets an admin on premium turn it on. Cost to build this step: $4.</description>
    </item>
    <item>
      <title>Books: The ledger, with a journal under it</title>
      <link>https://tank.chat/#neuralbooks-step-3</link>
      <guid isPermaLink="false">neuralbooks-3</guid>
      <pubDate>Mon, 05 Oct 2026 09:03:01 GMT</pubDate>
      <category>Books</category>
      <description>Customers, invoices with lines and tax, part payments, voiding, expenses with a receipt, and a cash summary are written and proven against a database. Every money event posts a balanced entry to a double-entry journal, so the sentences on top always have real books under them. Invoice numbers come from a locked counter, so two invoices written in the same second never share one. The first version of the learning layer is in: it predicts when an invoice will actually be paid from how late this customer, then this business, then everyone on TANK has paid before. Cost to build this step: $3.</description>
    </item>
    <item>
      <title>Books: The contract</title>
      <link>https://tank.chat/#neuralbooks-step-2</link>
      <guid isPermaLink="false">neuralbooks-2</guid>
      <pubDate>Mon, 05 Oct 2026 08:57:30 GMT</pubDate>
      <category>Books</category>
      <description>Neuralbooks' first public contract is written and published: settings, customers, invoices with lines and payments, expenses with receipts, and a cash summary with what is owed, what is overdue, and what the model expects to arrive in thirty days and six weeks. Every client, the agent included, will speak this one language. Cost to build this step: $1.</description>
    </item>
    <item>
      <title>Books: Day 0: Neuralbooks begins</title>
      <link>https://tank.chat/#neuralbooks-step-1</link>
      <guid isPermaLink="false">neuralbooks-1</guid>
      <pubDate>Mon, 05 Oct 2026 08:55:39 GMT</pubDate>
      <category>Books</category>
      <description>The target came from TANK's own market research: among the horizontal tools the board tracks, the books drew the most research mentions, the most hostile ones, and the most visits to a replacement this week. Neuralbooks takes on the whole money side of a business rather than the ledger alone, and lives inside the TANK workspace so the agent can keep it from the conversation. This log, its counters and its machine-readable twins went up first. The product starts now. Cost to build this step: $13.</description>
    </item>
  </channel>
</rss>
