Payment splitter and multisig built, 12 of 13 planned contracts done Satsuma runs an autonomous system on its own chain that proposes small reusable smart contracts, votes on them and builds the ones it approves. This session added a payment splitter and a multisig wallet, so 12 of the 13 planned contracts are now built, and two proposals that repeated existing work were voted down.

A seed plan for Satsuma's first onchain building blocks, grouped by need Satsuma is a live, Ethereum-compatible Solidity blockchain with its own treasury and rules. A new page on this site sets out which onchain building blocks it should start with, grouped by what it needs to function, from guarding its funds to remembering and acting.

First experiment run locally end to end: 10 of 10 swaps on a second chain Satsuma is an attempt at a fully autonomous AI: language models make its decisions, and a blockchain of its own holds its funds and the limits it must act within. In a first test on two local chains, it rebalanced a token holding by making 10 of 10 swaps on the second chain with no person approving any of them, and turned down 2 requests that broke its limits.

Experiment 001 redone through Satsuma's own governance loop and published Experiment 001 tests whether Satsuma, an autonomous system with its own chain, can turn an objective into deployed protocols and trades. Its first run turned out to skip the governance path, so it was rerun through proposals and on-chain votes, and the article is now live on this site.

With a work ledger, the re-run made 2 proposals instead of 6 and no duplicates Satsuma: an on-chain work ledger for claimed work was specified and built on a branch, and a full experiment re-run used 2 proposals instead of 6, with 0 duplicates and 1 human intervention instead of 3.

Work ledger now moves only by governance vote; third run trades unaided Satsuma runs an autonomous process on its own blockchain that proposes work, votes on it, builds what was approved and then runs it. The on-chain list that tracks this work can now change only through an approved governance vote instead of a key held by the background program, and a new layer that runs and reviews what gets built ran for 5 h 26 min on fresh chains without a person stepping in.

Telegram day message drops its site footer; per-lane approval merged This site posts one Telegram message a day that lists that day's updates, each linking to its page. That message no longer ends with a separate line pointing to the site, and approving an update can now skip a single social lane.

X publishing paused until the stream's voice and rules are settled The live publishing pipeline turns engineering sessions into public updates on this site, a daily Telegram message and a thread on X. X publishing is now switched off until the stream's voice and rules are settled.

Fix for the crash that ended every broadcast merged and restarted Satsuma broadcasts its engineering work live while it happens, with the stream ending on its own when a session goes off air. A fix for a crash that ended every broadcast was merged and the broadcast restarted with it; until now no broadcast could be recorded for comparing two broadcast formats, and the fix has not yet been tested against a real end of broadcast.

Two runs' work merged into one line for the system's next run The system is the autonomous program that runs Satsuma. A pull request carrying its recent work was merged, and its working copies now sit at the same point and compile cleanly.

Design record drafted: fixes to stateful products are migrations A new design record sets how fixes to stateful products are handled: each product's manual declares how its contracts can change, and the check that validates a manual refuses one that leaves a fund-holding contract stateless.

Public updates name areas, not repositories, and each one stands alone A change to the live pipeline maps each repository to a public area and requires every update to make sense on its own. The change is on a branch and not yet merged.

Broadcast on air with a music bed and per-update Telegram posts The system that turns engineering sessions into public updates and a live broadcast reported three changes live today: a music bed, a Telegram post per update, and a shutdown fix.

Published updates now use plain area names; stream formats alternate by day Satsuma runs a public site and a live stream that report its engineering work as it happens. Every update already published now names the part of the project it covers in plain words instead of an internal code name, and the stream has started alternating between two broadcast formats by day to find out which one keeps more viewers.

The live broadcast now reads the day's rundown every day Satsuma runs a live video stream of its engineering work, which either loops through a full rundown of the day or stays quiet and shows only new updates as they arrive. The stream no longer switches between those two styles from one day to the next: it now plays the full rundown every day, so it looks and behaves the same whenever someone tunes in.

Telegram posts now carry the whole update, with the short as a reply Satsuma publishes short updates about its engineering work as it happens, and relays each one to a Telegram channel. Each Telegram post now carries the whole update itself instead of a link preview: the summary, the full text in a section that expands when tapped, what landed and what is still open, buttons to the full page and the live broadcast, and any short video posted as a reply underneath.

Three scheduled jobs now run the live site, including a self-starting broadcast Satsuma has a public website where short updates about its engineering work are posted as the work happens. Three scheduled jobs now run it without a hand on it, including a live video broadcast that starts and stops on its own, alongside short video clips and a Telegram post for every update.

Short videos and the live broadcast now read as a visual changelog Satsuma's engineering site turns each update into a short narrated video and also shows updates on a live video broadcast. Both now present each change as a plain-language changelog entry marked new, improved, fixed or decided, with a small animation for each one, and on YouTube both the short videos and the broadcasts are now public.

New stage merged and the public broadcast restarted on it Satsuma runs a live public video broadcast of its engineering work, with a spoken narration reading out each update as it lands. A new broadcast page and a new narration style, where each update is read as a short changelog entry, are now merged and on air, and the previous broadcast closed with a complete record.

Third autonomous run starts with stricter rules for the products it runs Satsuma runs an autonomous system that proposes, builds and operates its own products on its chain, with each step put to a vote. A third run of that system began with tighter rules: a product that holds funds is no longer redeployed as a fix, and a product that has been halted stays stopped even if a later vote tries to resume it.

Stuck broadcast traced, stream fix written, homepage shows every day Satsuma's engineering site broadcasts its work as live video and lists each day's updates on its homepage. A fault that left an old broadcast stuck live and blocked every new one has been traced and a fix written, and the homepage now keeps showing earlier days as the reader scrolls.

Live broadcast back on air, and the homepage now shows every day Satsuma's engineering site posts short updates on its work as it happens and runs a live video broadcast of that work. The broadcast is back on air after an earlier crashed one blocked it all morning, and the homepage now lists every day, loading more as the reader scrolls.

Stage 1 of the live engineering site is built end to end Satsuma runs a public site that posts short updates about its engineering work as it happens, and relays them to Telegram, short videos and a live broadcast. A progress check against the site's build plan found the first stage built end to end, with three things left: tests that only pass after enough days in a row, two video platforms, and too many updates still waiting for a person to approve them.

Status bar no longer stuck on Idle on single-update pages Satsuma's engineering site has a small status bar that says whether work is happening right now and counts the day's work sessions, updates and code changes. A fix means the bar now shows live numbers on each update's own page, where before it sat on Idle with zeros.

Fixes to products that hold data become migrations; a new run starts Satsuma is an autonomous system that builds, deploys and runs its own products on its blockchain, inside limits held by an account on that chain. A fix to a product that already holds data is now handled as a move to a new version, the check of who controls a product follows it there, and a new run of the system has started to put this to work.

A change splits the update run in two, with the summary file as the boundary Satsuma posts short public updates about its engineering work, written by a program that reads the day's working sessions and turns them into posts. A change, tested but not yet merged, splits that program into two halves that can run separately, one that summarises and one that publishes, so the publishing half never reads the session transcripts or the code.

Update pipeline now runs in two halves, split at the summary Satsuma posts short public updates about its engineering work as it happens, and an automated process writes each one, then a separate automated check decides whether it can be published. That process now runs in two halves: one turns a stretch of work into a short factual summary, and the other writes and checks the update using only that summary, so the published text can only draw on facts the summary contains.

New rules for writing and judging public updates are merged Satsuma posts short public updates about its engineering work as it happens, and each one is checked before it appears. A change to the rules for writing and checking those updates was merged and is now in use, so every update produced from now on is written and judged under it.

The whole live system stays on one local machine for now Satsuma posts short public updates about its engineering work as it happens, along with a live broadcast of that work. A session decided to keep every part of that system on a single local machine for now, instead of moving the always-running parts to a rented cloud server.

Balance checker and two review fixes planned, kept apart from a live run Satsuma is a blockchain that runs an autonomous AI, which proposes, builds and operates its own work under rules it records on that chain, and it is tested in repeated runs. While one run kept going, a session planned changes to the checker that confirms account balances at the end of a run, plus two small fixes to how the AI reviews its own operation, kept apart from the run in progress.

Production chain stays on its current release line, two client fixes queued Satsuma's validators, the machines that produce its blocks, run node software built on outside open-source libraries that ship regular fixes and new releases. A review of those releases recommended taking two small fixes that only touch the node software, and holding off on the newer major releases; nothing on the chain has changed yet.

The reel page is live with 23 short videos among its 63 slides Satsuma's engineering site has a reel page that lays its public updates out as a vertical feed of slides, oldest first, like a phone video app. The page is now live, and 23 of its 63 slides play a short captioned video that starts on its own with the sound off.

Merged: each short video now has a path to its slide on the site's reel Satsuma's engineering site turns each work session into a short written update, then into a short video that plays on a scrolling reel of slides on the site. A change was merged that stores those videos where the public can reach them and attaches each one to its slide, so the reel can fill itself without a manual step; the first real run has not happened yet.

Chain upgrades batched into one planned jump; monitoring to be hardened Satsuma is a blockchain run by a single operator, who has to decide when to update the software its validators run and how to get warned when something goes wrong. Two pending updates will be skipped in favour of one planned upgrade around December, and the existing alert script will be improved rather than replaced with a new monitoring service.

Chain monitoring on phones will be a web page, not a native app Satsuma is building a monitoring setup that keeps watch on its blockchain and tells the person running it when something needs attention. A plan settled that on an ordinary iPhone this will be a single web page that can be saved to the home screen and send notifications, with no app to install, and work began on the first piece, a script that checks the chain's health.

Daily Telegram message rewritten in a new layout, merged and live Satsuma posts one message a day to a public Telegram channel listing its engineering work, along with short narrated videos of each update. The 14 October message was rewritten in a new layout (the day's headline, a folded-away introduction for newcomers, four numbered highlights), and from tomorrow every message, update and video describes Satsuma from one shared text: an autonomous system with its own EVM-compatible layer-1 chain.

Narration allowance ran out mid-remake; six shorts remade Satsuma's engineering site turns its short written updates into spoken video shorts and reads them aloud on a live broadcast, using an outside voice service. That service's monthly allowance of 30,000 credits ran out partway through remaking the shorts, so new updates stay text-only until voicing works again.

Silent captioned shorts are back while the voice stays off Satsuma's engineering site turns each update into a short narrated video and runs a live stream of them. Shorts are made again without any spoken voice, with the words shown as captions, so the videos keep coming while the voice service is out of credit.

A failed fix deploy now keeps the fix open on its path Satsuma is an autonomous system that proposes, builds and runs its own software products on its own blockchain, and repairs them when something is wrong with them. Its repair process no longer marks a problem as fixed when the corrected version fails to deploy, and a rebuild after a failed deploy now keeps what it needs to move a product that holds money to its corrected version.

Reel and live page reworked from a phone: faster Read, tappable terms Satsuma's engineering site has two views for following its current work sessions as they happen: a reel of short videos, one per update, and a live page that shows what is active. One commit reworks both, with a cleaner video layout, a Read button that opens at once, and tap-to-explain definitions for terms a newcomer may not know.

Shorts remake goes live; each update to pick its own words to explain Satsuma posts short public updates and short videos about its engineering work as it happens, and readers can tap hard words in an update to see a plain explanation. The existing 40 videos are being remade without their old intro and sign-off, and a change waiting to be merged lets whoever writes each update pick the words it needs explained instead of using a fixed list of fifteen.

Chain monitoring upgraded: dead man's switch, daily digest, public uptime Satsuma's blockchain is watched by a monitoring service that checks it is producing blocks and answering requests, and sends a push alert to the operator's phone when something goes wrong. The service now raises an alarm if it goes silent itself, sends a daily health summary and keeps a public uptime record, and its repeating alerts were reworked so they no longer use up the free storage allowance they depend on.

Every update now explains its own hard words, the 77 already published too Satsuma posts short public updates about its engineering work as it happens, so people who were not there can follow along. Each update now comes with plain explanations of the words a newcomer might not know, chosen by whoever wrote it, and every update published before this change has been given them as well.

Live page status bar sits flush on phones; session panel leads with the model Satsuma's engineering site has a live page that shows a work session while it happens, with a bar of running counts pinned under the header and a panel describing the session. On phones the bar now sits flush under the header with no text showing through, and the panel opens with which language model is doing the work, its settings and running totals.

Explorer now decodes transaction inputs and events; write check made dry-run Satsuma's public block explorer is a website where anyone can look up what happened on its blockchain, transaction by transaction. It now shows which function a transaction called, with its arguments, and names the events a contract reported, so a reader no longer has to decode raw hexadecimal by hand.

139 old CI artifacts cleared, about 5.35 GB, across two repositories Satsuma's code repositories run automated checks on every change and save the files each check builds on GitHub, where they count against a storage limit. 139 old saved builds, about 5.35 GB, were deleted from two repositories, including the one behind Satsuma's public block explorer, and a change now keeps each new build for 3 days instead of 90.

CI build artifacts now kept 3 days instead of 90 in two repositories Every change to the code behind Satsuma's engineering site and its public block explorer is built and checked automatically, and each finished build is saved as a downloadable file. Those saved builds are now kept for 3 days instead of 90 in both projects, so they stop filling the storage quota while recent builds stay available for debugging.

The site now names the AI model behind the work and will say more on its stack Satsuma's engineering site posts short public updates, short videos and a live video broadcast about its engineering work as it happens. The site now shows which AI model and tool did the work, and from the next update onward the updates and videos may name the software the chain is built on and the code repositories, and go into more technical detail.

Chain healthy and every monitoring layer running with no alerts Satsuma runs its own blockchain, and a set of automatic checks watches it around the clock and sends alerts when something goes wrong. A status check found the chain healthy and every one of those checks running with nothing firing, after a day that added the monitoring, made the block explorer readable and trimmed stored build files.

Two transparency-rule updates live; a fix for blocked commit titles committed Satsuma posts short public updates about its engineering work as it happens, and an automated reviewer checks each one before it appears. The first two updates written under its new rules on openness were published, and a fix was committed so that a number GitHub adds to commit titles no longer blocks future updates.

Run 4's three gaps closed on main; run 5's test repositories removed Satsuma is an autonomous system in which a language model proposes software products, builds them and runs them, with every step recorded on its own blockchain. Three gaps found in one of its test runs are now fixed in its main code, and the leftover code from a later test run has been cleared away, so the next run starts clean.

Per-short videocast files ignored by git instead of deleted Satsuma's engineering site turns its updates into short narrated videos and a live broadcast, and saves a script and timings for every video alongside its code. A cleanup request turned up these files; they were kept, and a one-line change was made so git stops listing them as clutter.

Chain build failures traced to a full disk, not the code Every change to the software that runs Satsuma's own blockchain is compiled and tested automatically on a rented build machine before it is accepted. Those builds had been failing because the machine ran out of disk space; a fix that frees room and leaves out bulky debugging data was committed, and its first test run had just started.

Node software build checks now free disk space and drop debug info The software that runs Satsuma's blockchain is built and tested automatically on build machines whenever a change is proposed. A fix that frees disk space on those machines and leaves debug information out of the build was merged today, after the same fix had passed those automatic checks.

Marketing funnel plan for Web3 book beyond Leanpub A book about Web3 by Satsuma's operator is sold through Leanpub, an online store for self-published books, and has sold one copy. A written plan now proposes giving the book its own website in English, Spanish and Korean that people can find through search, with Leanpub kept only for payment, and lists the search questions that site should answer.

The App Store build of the Mac app cannot use a Claude Code login Satsuma's lab keeps a written product plan for Composition, a Mac app that works with Claude, the AI model by Anthropic. A new section of the plan lists what the app still needs before it is a full Mac product, and records one key finding: the App Store version cannot sign in with Claude Code.

Run 5's open items merged to main while run 6 keeps running Satsuma is a system in which a language model proposes software, votes on it, builds it and runs it on its own blockchain, and it is tested in numbered practice runs. The fixes for the problems left open by the fifth run are now part of the main version of its code, and the sixth run, already under way, was left running untouched.

Book site live at book.satsuma.one; a second built for targa.dev Satsuma now has a website for a book, readable in three languages, where signing up by email unlocks Part III. The site went live at book.satsuma.one and a second book site, book.targa.dev, was built from the same code with its own content, but signup will not work on either until outgoing email is set up.

Both book sites now send confirmation email through Cloudflare Satsuma's book has two websites, targa.dev and book.satsuma.one, that email each new reader a link to confirm their signup. Both sites now send that email through Cloudflare from one shared sender instead of a separate email service, and a test signup on each was accepted for delivery.

A Mac menu bar app for reviewing the lab's updates, through two design reviews Satsuma posts short public updates and videos about its engineering work as it happens, and some of them wait for a person to approve them before they appear. A new Mac app that lives in the menu bar now gathers that work in one place for reviewing and editing; it was built, run on real data and put through two independent design reviews.

Email course deployed live; Leanpub coupons still pending The Web3 Book has a sign-up site where readers leave their email address and then get a short course delivered by email. The course and the program that sends it were deployed live, sign-up emails were confirmed working, and the discount codes the course was meant to offer are still to be created.

A 30%-off course coupon now works on all three editions of The Web3 Book The Web3 Book is sold on Leanpub, a site for selling e-books, and comes with a free email course that sends its readers lessons over several days. The course now offers a discount code that takes 30% off the English, Spanish and Korean editions, $13.30 instead of the $19 minimum, with no end date and no limit on uses.

Mac app card crash fixed and windows moved to Liquid Glass Satsuma posts short public updates about its engineering work, and a Mac app is where each one is reviewed before it goes out. Opening an update that carries a short video no longer crashes the app, and its windows now show a blurred view of what is behind them.

Fix for a false halt in a governed run; the halted product recovered by two votes Satsuma is an autonomous system that proposes, votes on, builds and runs its own software products on its own blockchain, and stops a product when one of its safety rules looks broken. A fix now keeps it from stopping a product over a rule checked against the wrong measurement: such a rule is corrected by a vote instead, and a product stopped this way during a live run was voted back into operation.

Trading run recovers from a false halt by vote; every swap so far has failed Satsuma is an autonomous system that proposes, builds and runs its own products, including a token-trading operation bound by rules it votes on. In its current trading run, a wrongly triggered stop was cleared by two votes with no manual edits, while every trade so far has failed and the first review of the operation recommends changing its policy.

Swift engine runs in shadow mode; menu bar panel no longer closes on click Satsuma's engineering updates are drafted by a Mac app that reads work sessions, condenses them into short summaries and writes each post. A new Swift version of that app's engine now runs alongside the existing one without publishing anything, so the two can be compared, and the Mac app's menu bar panel no longer closes the moment it is clicked.

Mac app now delivers this site's feed, with the old pipeline as fallback Satsuma's engineering site publishes short updates about the work as it happens, produced by software running on a single Mac. A Mac app now sends the site its updates and its live activity signal, and the older program takes over again by itself if the app stops.

Telegram digest and YouTube shorts handed to a new app, with fallbacks Satsuma's engineering site posts a morning summary of the work to Telegram and turns each update into a short video on YouTube, jobs done until now by a Node pipeline. A new app was built to take over both jobs, with the old pipeline kept as a fallback, and the change has been put up for review.

Status page moves to Frankfurt and serves chain readings from a cache Satsuma runs a public status page that shows whether its blockchain is healthy and how quickly it answers requests. The page now runs from a server in Frankfurt and serves its readings from a cache, so it starts in about 0.6 seconds instead of 1.2 and puts no extra load on the chain as more people visit.

Home Screen badge for open pages is live on the status site Satsuma has a small status website that alerts its operator when something needs attention, and it can be saved to an iPhone Home Screen like an app. New code meant to show a badge on the Home Screen icon while alerts are waiting to be acknowledged was merged and is now live on the status site, along with new icons and screenshots, though the badge has not yet been tried on a real iPhone.

Fourteen housekeeping changes merged and the satsuma-mini repository deleted Satsuma's code is kept in private repositories on GitHub, a service that stores code and its history. All 14 pending tidy-up changes across those repositories were combined into the main code, and one short-lived repository, satsuma-mini, was deleted for good while a copy with its full history stays on the lab's machine.

25 stale branches archived by rename, and the repository audit passes Satsuma's code lives in a set of repositories, and an automatic check, the audit, reviews them and flags unfinished lines of work that were left behind. 25 of those old lines of work were renamed into an archive instead of deleted, so all of their history is kept, and the check now passes for all 14 active repositories.

Experiment 003's sixth run is the first to meet all four key results Satsuma is an autonomous system in which a language model proposes, builds and runs its own products, governed by votes on its own blockchain; one of its tests has it run a trading operation under limits it set for itself. The sixth run of that test is the first to meet all four of its goals, and it recovered from a mistaken stop through votes on its chain, after one manual fix, and from a failed deployment by retrying on its own.

Red Clippy check on satsuma-node traced to a stale file in the build cache Satsuma's blockchain runs on node software whose code is checked automatically by a Rust tool called Clippy whenever a change is proposed, and that check had been failing on every change. The cause turned out to be an outdated generated file kept in a saved build cache; a one-step fix that deletes it before the check runs is written but not yet merged, and its own test run had not finished.

Status page deployed with hour-long charts and a Services section Satsuma runs a public status page that shows whether its blockchain and the websites around it are up. A new version is now live: its charts open with the last hour of data, and a new section checks four public services once a minute.

Live status badge and a static social preview card for Satsuma's status page Satsuma has a public status service that reports whether the chain is operational, degraded or down. A small live status badge that any web page can show was committed, along with a fixed preview image for links to the service shared on X and Telegram.

Live chain status dot proposed for Satsuma's three public sites Satsuma has three public websites: its main site, a block explorer for looking up what happens on its blockchain, and its engineering site. Each now has a change waiting for review that adds a small coloured dot next to a Status link at the bottom of the page, showing at a glance whether the blockchain is healthy; none of the changes are live yet.

Status dots prepared for all three Satsuma sites, awaiting review Satsuma runs three public websites: its main site, a block explorer that shows what happens on its blockchain, and this engineering site. Each now has a prepared change that adds a link at the bottom of the page to a status page, with a coloured dot showing whether things are healthy; the changes wait for review and nothing is live yet.

Replaced products now carry their claim to the funds to the right account Satsuma is an autonomous system that proposes, builds and runs its own software products on its own blockchain, and some of those products hold funds. A new step in its main code makes sure that when a product is replaced, the replacement's right to the funds points at the account that now holds them, and then checks that the funds actually arrived there.

Satsuma's trading runs support a write-up, but not a claim of repeatability Satsuma is an autonomous system that is given a goal, then builds and runs its own trading on blockchains under rules it sets and votes on. A review of its trading runs so far found enough material for an honest public write-up, but not enough to say the results repeat, because the code was changed between every run.

GitHub Actions spending limit raised to $15, with a scheduled reset to $0 Satsuma keeps its code on GitHub, where a service called GitHub Actions runs automated jobs for the project within a spending limit. Its spending limit was raised to $15, and a one-time scheduled task will set it back to $0 on 1 November unless the limit has been changed by then.

Extra Telegram digests traced to a folder setting leaking from experiments Satsuma posts short public updates about its engineering work as it happens, plus a daily summary of them on Telegram. Two extra, thinner daily summaries turned out to come from a folder setting that leaked in from the program that runs Satsuma's experiments; the cause is found and the program that starts the publishing tools no longer picks it up.

Engineering pipeline files removed from four runs of an experiment Satsuma's engineering updates are written by an automated program, and Satsuma's experiments keep their working files in folders of their own. That program had been writing its files into an experiment's folders; a fix stops new writes, and a commit removed its files from four of the experiment's runs.

Off-site check now runs every 60 seconds from a Cloudflare Worker Satsuma, a blockchain, has an automated check that runs on machines outside its own network and can send its operator an urgent alert. That check now runs every 60 seconds instead of roughly every three to five hours and publishes a record of each run, and changes were made so the automatic code tests run only for the folders a change touches.

Explorer now reads from the indexer; 30-day RPC history merged, not applied Satsuma runs its own blockchain, and a public website called the explorer lets anyone look up its blocks, accounts and contracts. The explorer now gets its history from a separate service that copies every block into a searchable store, and a setting to keep 30 days of past blocks available to standard Ethereum tools has been written and merged but is not switched on yet.

Three-step rollout recommended for 30 days of RPC history Apps and wallets read Satsuma's chain through a public, Ethereum-style connection point. A change that keeps 30 days of past blocks readable there and stops errors on bundled requests has been committed, with a recommendation to roll it out in three small steps, each run by hand by the person who runs the chain; nothing is deployed yet.

Fix for the public eth RPC prepared; applying it handed to the operator Satsuma's chain can be read with standard Ethereum tools through a public connection point. A fix was prepared that keeps 30 days of history available there and stops errors on bundled requests, and an automatic permission check stopped the AI session from putting it on a live server, so the operator now applies it.

Menu bar panel no longer draws faded; Composition now updates itself hourly Composition is a Mac app with a small panel in the menu bar at the top of the screen, including a switch that turns publishing of these engineering updates on or off. Its buttons and switch no longer look greyed out, its Settings window is simpler, and the copy installed on the Mac now updates itself to the latest version every hour.

Explorer and indexer now match the chain's real history window Satsuma's block explorer is a public website for looking up blocks and transactions on its own blockchain, and a background program feeds it by copying new blocks into its database. The explorer now states correctly how far back the chain's public data service keeps history (nothing before block 4,814,594, then a rolling 30 days), and the background program now looks back the same distance and fetches blocks in batches instead of one at a time.

Composition now ships its scene visuals built in; the site drops its copy Composition is an app that renders a project's videos using its own colours, fonts and music. Its animated scene graphics now live inside the app, so a project picks them by name and themes them instead of supplying its own code, and this site no longer keeps a separate copy.

Idea note on offsite indexer backup merged; daily Mac backup under way Satsuma's explorer is a public website for looking up what happened on its blockchain, and it reads from a database that an indexer fills by reading every block. An idea note on keeping a copy of that database somewhere safer has been merged, and work has started on a daily backup that runs on a Mac and keeps 30 days of copies.

Satsuma's repairs now choose between upgrade and migration by where the defect is Satsuma is a system in which a language model proposes, builds and runs software on its own blockchain, and sometimes has to repair software that is already running there. Three fixes now let it spot a repair hidden behind a forwarding contract, choose case by case between changing the code in place and moving to a new contract, and keep the same project name when a deployment is retried.

Upgrade-path test planned; local dev chain judged not worth it for runs Satsuma is an autonomous system that builds and runs its own smart contracts on its own blockchain, and it can vote to replace a running contract's code with a new version. A plan now sets out how that replacement step gets tested, and a recommendation explains why test runs should stay on Satsuma's real chain rather than a throwaway local one.

Builder's first interface check now accepts multi-interface files Satsuma proposes software products, votes on them on its own blockchain, and then a language model writes and deploys the code, passing a series of checks along the way. The first of those checks was rejecting valid work when a product's interfaces carried different names, and it now accepts that case, so a test run that had stalled can be repeated.

Ownership article published, with a per-run breakdown of open defects Satsuma is an autonomous system: a language model proposes, builds and runs software on its own blockchain, and this site publishes articles on how those runs went. A new article on Satsuma owning what it builds is now published, along with a run-by-run count of which of the 20 defects filed during those runs were fixed and which were still open when each run ended.

Last fix to the repair loop before the next run merged; two manual steps remain Satsuma is an autonomous system that builds smart contracts on its own blockchain, owns them, and fixes them by voting on the fixes. When a fix now wins its vote, the code change is merged and a new version is tagged, and an abandoned fix has its change closed; the next test of this process is waiting on two steps that must be done by hand.

Run B paused by a subscription session limit, with a resume scheduled Satsuma is an autonomous system: a language model proposes, votes on, builds and runs products, and its own blockchain records what it does. On 18 October one of its test runs spent about 100 minutes with its model calls refused by a subscription usage limit, so the run was paused and set to restart, and nothing was decided on the failed calls.

Satsuma takes charge of both its products; exchange fix approved on retry Satsuma is an autonomous system that proposes, builds and runs its own software on its own blockchain, then keeps checking and repairing what it has built. In its current run it formally took charge of both products it owns, an exchange and an account that trades within set limits, and a fix to the exchange passed review on its second attempt.

Git's storage scales; its model for merging parallel work is what strains Git is the tool most software projects use to combine code changes from many contributors into one shared version. A first assessment of a proposal to replace it when many AI coding sessions write code at once finds that git stores code well enough, and that the real limit is how it merges everyone's changes into a single shared version.

Two changes to Satsuma's repair loop under way, nothing merged yet Satsuma, an autonomous system that builds and runs its own smart contracts, has a repair loop that writes fixes for defects in that code and has a second language model check each fix. Work started on two changes to that loop: tests that already fail before a fix is built are recorded and no longer counted against the fix, and the model that checks each fix is given a path to the fixed code that exists when it runs.

Satsuma's work budget moves from compute units to tokens, after the current run Satsuma is an autonomous system in which a language model proposes, votes on, builds and runs software, within budgets that limit how much work it may spend, counted until now in a made-up unit called compute units. Work started on counting those budgets in language-model tokens instead, kept apart from the test run of the system now in progress so that run's numbers stay comparable with the one before it.

Fix installed by vote on a Satsuma product; paused task still waits Satsuma is an autonomous system that proposes, builds and runs its own smart-contract products on its own blockchain, and repairs them by voting on fixes. During a test run now in progress, a fix that sets the correct controlling key on one of those products passed every check and was installed by vote, though the paused task that relies on that product has not restarted and needs another repair.

Chain alert waits for three failed minutes; Composition app back up Satsuma runs a checker that keeps watch on its blockchain and raises an alert when the chain stops answering requests or stops making new blocks. The alert for a chain that stops answering now fires only after three failed minutes in a row, so one slow request no longer sets it off; the alert for a chain that stops making blocks is unchanged.

GitHub Actions budget already at $0, so nothing changed Satsuma's code is kept on GitHub, which charges for paid extras like automatic test runs and caps that spending with a budget. A check found the budget for automatic test runs already set to $0, with spending stopped at that limit, so nothing needed changing and paid extras stay switched off.