Satsuma Engineering
Every session of work on Satsuma becomes an update here within minutes of ending: what landed, what was explored, what was decided. Filtered by the same rules as everything on this site.
A spam filter for chat groups uses an AI model to read incoming messages and raises an alert when many messages in a day go unread. An alert about 513 unread messages from one day turned out to be expected: they all came from one group without a paid plan, where AI reading is switched off, and nothing is broken.
Satsuma runs its own blockchain, along with public websites and small services that watch over it. A routine status check found the chain adding a block about every 2 seconds and every public site loading, with one low-priority warning still open.
Cloudflare's cloudflared is a small program that links a server to Cloudflare's network so a website can be reached without opening the server to the internet directly. Claude checked a Cloudflare email asking for version 2026.10.2 or later, found that the versions it named match Cloudflare's own GitHub releases, and found that Satsuma's servers do not run the program.
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.
Satsuma runs a small automatic checker that keeps asking its blockchain's public entry point whether it is answering, and sends an alert when it is not. A burst of alerts turned out to be false alarms, and a fix was merged so the checker retries and only alerts after three failed minutes in a row. The fix takes effect once the checker is redeployed.
Satsuma is an autonomous system: a language model proposes, builds and runs software on its own blockchain, in long sessions that follow limits it votes on. One of those sessions sat paused for about 11 hours by a weekly usage limit, then resumed with nothing lost and went back to building a fix to an exchange it runs.
books.satsuma.one is the website for Satsuma's book, with a header, a Buy the book button and a box offering a free chapter. A fix now live there removes a stray language label, keeps the button's text readable, and gives the free-chapter box the same dark card style as the rest of the page.
books.satsuma.one is a website that presents books, with a library page, a language menu and a light or dark colour scheme. Three display bugs on it are fixed and live: a stray Language label is gone from the header, the button for buying a book stays readable when the pointer is over it, and the free-chapter signup box now matches the dark scheme.
Some of Satsuma's engineering work runs for many hours on a Mac, carried out by an AI coding assistant. Before the next long run, the assistant started watching the Mac's power source and will send the operator a push notification if the Mac drops to 30% on battery, so a long run is less likely to stop partway.
Satsuma is an autonomous system that proposes, votes on, builds and runs its own products on its own blockchain, and the lab tests it in long recorded runs. The third attempt at one of those runs was lost when the computer running it went down, and a fourth attempt started on 2026-10-22 with the same settings and code.
Satsuma's lab is designing rules for how code changes get proposed and accepted when very large numbers of AI coding agents work on one codebase at the same time. The design was attacked by AI reviewers and revised. A simulator then replayed the real change history of three open-source Rust projects to measure how often changes would collide.
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.
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.
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.
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.
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.
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 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.
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.
Satsuma publishes long technical articles about its engineering on its public website, and drafts are read before they are published. One unpublished article was turned into a private page made for reading on a phone, word for word, with its figures, tables and glossary adjusted to fit a small screen.
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.
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.
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.
Satsuma's block explorer is a public website for reading its blockchain, and it keeps its own copy of the chain's history in a database. A scheduled backup for that database was drafted, because the chain's public endpoint keeps only 30 days of history, so from 2026-10-15 on the database is the only copy of older history; nothing yet shows the backup committed, run or tested by restoring from it.
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.
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.
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 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.
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.
Satsuma publishes short videos and a live broadcast about its engineering work, each with quiet background music underneath. That music has been replaced by an original track generated from scratch, so the project owns it outright, and the video tool it uses was checked and found free for a company of this size.
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.
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.
Satsuma's code lives in several repositories, each running automated checks on new changes and publishing its websites automatically. Six changes merged today make those checks run only when a change needs them and stop sooner if they hang, and the outside check that Satsuma's public services are up now runs every minute instead of every few hours.
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.
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.
Satsuma's code is tested and built automatically by GitHub Actions, a service that charges by the minute once a free monthly allowance runs out. An audit found the project on pace for about 3,900 minutes in October against 2,000 free, and proposed fixes, not yet made, starting with stopping one repository's checks from running on every push to every branch.
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.
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.
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.
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 is an autonomous system in which a language model proposes, builds and operates its own software products on its own blockchain, and it is tested in long numbered runs. A seventh run started from the newest code to watch two untested behaviours happen live, and it kept going on its own after the AI session watching it stopped at its usage limit.
Satsuma's engineering website and its block explorer, a public page for browsing the chain's records, are rebuilt and checked automatically on GitHub's servers every time their code changes. The engineering site's checks kept failing because each run uploaded a full copy of the site that nothing used; two proposed changes remove that upload and pass their checks, and this update explains the remaining risk: October's free computing minutes are running low.
Satsuma's engineering site uses a Mac app that reads work sessions and has Claude or Apple's on-device model draft, judge and edit posts from them. A full click-through found no crashes, and the first audit fixes make its privacy choices binding: nothing goes to Claude unless Claude mode is on and consent has been given.
Satsuma runs its own blockchain, and looking up its past blocks and balances depends on how much history its computers keep. After the operator said there was no budget for more, a plan costing $0 a month on hardware Satsuma already pays for was proposed; none of it has been applied yet.
Satsuma's three public websites (the main site, the block explorer and this engineering site) now carry a small dot at the bottom of each page that shows whether Satsuma's blockchain is running normally. The changes that add it turned out to be already published, and all three sites show the chain as operational. A separate fault was found: automated checks on two code projects fail because the shared storage for their build files is full.
Satsuma has three public websites: its main site, a block explorer where anyone can look up what happens on its blockchain, and this engineering site. Each now carries a small status dot that reads a status response, and the change was merged and deployed to all three, with the deployed pages checked but not yet each opened in a browser.
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.
Satsuma's engineering site, engineering.satsuma.one, streams its work live on YouTube, and a long-running program keeps that broadcast going. The program was restarted on new code and was back on air four seconds later as a new broadcast; its log now shows that one app, called Composition, is the only one sending the broadcast's live data.
Satsuma has a public status page at status.satsuma.one that shows whether its services are working. It now also serves a small live badge that other pages can embed and a preview card that appears when the page is shared, which completes the page's planned build.
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.
Satsuma's engineering site is run by a program that writes short public updates and videos about the work as it happens. A status check found that program running steadily, with an older copy of the process that keeps the site's live YouTube broadcast on air still running alongside it, and no decision yet on when to restart it.
Satsuma's engineering website is run by an automated program that writes short updates about the work, checks them before they go out and turns them into short videos. That program is being moved to a new app, which now handles three of its four jobs, with the old version standing by to take any job back if the new app stops responding.
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.
DNS is the internet's address book, and the entries for satsuma.one, Satsuma's web domain, are managed in Cloudflare's dashboard. An attempt to add a TXT record, a short text entry in that address book, did not finish, so nothing about the domain changed.
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.
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.
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.
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.
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.
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.
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.
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.
Satsuma keeps its code in a set of repositories on GitHub, where each project's page carries a short description, links and a README that introduces it. An engineering session with Claude checked how every repository is described and set up, and drafted a plan to tidy them; no changes are recorded as applied.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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.
engineering.satsuma.one is a website that posts short public updates about Satsuma's engineering work as it happens, with short videos and a live broadcast that reads them aloud. A status check found everything running with nothing stuck, and counts how many updates have been published, held for review or dropped so far.
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.
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.
Satsuma's engineering site publishes research articles and short videos alongside its live updates on the work. An unfinished article about Sei, another blockchain, and some set-aside video work were deleted from the local copy where they were kept. None of it reached the published site, and the working copy is clean again.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Satsuma's own blockchain is watched by two dashboards: a public status page anyone can open, and an internal monitoring dashboard that can only be reached from a private network. A check today found both live, with the internal one serving a valid certificate, 16 working panels and all 8 of the sources it collects measurements from reporting in.
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.
Satsuma posts short public updates about its engineering work as it happens, and its Telegram channel now gets one message a day that rounds them up. The first of these daily messages went out for 14 October, and a change waiting to be merged makes every piece of writing describe Satsuma from the same checked text, so a newcomer gets the same account wherever they start.
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.
Satsuma has a status page and a small dashboard that show at a glance whether its blockchain is healthy. A session looked at how those screens could be laid out on a folding phone, closed and open, and no code was written.
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.
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.
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.
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.
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.
Satsuma's engineering site makes short videos about its work and plays them in a reel, which needs somewhere online to store the video files. A storage service was set up as far as its payment step, and that step was left for a person to approve, so for now the reel still shows text cards instead of videos.
Satsuma has an autonomous system that proposes, builds and runs its own software, and each test of it takes hours and leaves behind copies of the code it built. Those leftover copies were deleted, and a breakdown of one 287-minute test run found that building took about four of those hours. Which parts to speed up for testing is still undecided.
Satsuma runs a public site that reports its engineering work as it happens, and that site needs a file storage bucket set up with its hosting provider. A session opened the provider's permission page, and the setup is not finished yet.
Satsuma's autonomous system is tested in experiment runs, and each run creates its own private code repositories for the products it builds. A new script removes those leftover test repositories once a run has been archived, and seven left by the first three runs have been counted and confirmed as test-only, not yet deleted.
Satsuma is a blockchain with an autonomous system that proposes the software it needs, builds it and deploys it on its own. A status check one hour into a new run of that system found it healthy, with its first approved proposal being built and a second approved proposal waiting its turn.
Satsuma's engineering site has a phone page called the reel, which shows the last forty public updates about its engineering work, one per screen, newest first. A session went over what the page is for and found two gaps for readers catching up: it has no video, and it always starts at the newest update instead of where a reader left off.
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.
Satsuma runs a live broadcast that reads its engineering updates aloud on a loop while work is under way. A working session checked whether someone returning after a few days away could use it to catch up, and found it only covers the current day.
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.
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.
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.
Satsuma's engineering site is fed by a pipeline that turns recorded work sessions into short public updates, and all of it runs today on a single local machine. A review asked whether that design could move to the cloud, recommended no redesign, and named two parts that would need to change, though the full list of changes is cut off in the record. No code changed.
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.
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.
Satsuma broadcasts its engineering work as a live video stream and also posts short clips cut from that work. A question about how the video gets out was answered: the broadcast is a true live stream, the short clips are uploaded, and no code changed.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
This site runs a live broadcast that reads the day's engineering updates aloud. A pull request was merged and the broadcast restarted on it. The restart exposed two defects, and fixes for both are in a second pull request.
Satsuma runs a live video broadcast of its engineering work, with a spoken voice that reads out short updates as they are posted to its engineering site. A report of no sound turned out to be expected behaviour: the voice stays quiet until a new update is published while the broadcast is on air, and none had been.
Satsuma's engineering lab can now broadcast its working sessions as live video, alongside two automatic jobs that already run every five minutes and nightly. The first broadcast has started as an unlisted stream, so it can be reached only through its link until it is switched to public.
engineering.satsuma.one is a public site that reports Satsuma's engineering work as it happens, published by a nightly job, with a live broadcast of the work. Changes to this site and to Satsuma's main website were merged, the nightly publishing job was given its own credential, and the scheduled job that starts the broadcast still has to be installed by hand.
Satsuma's engineering site posts short public updates about its engineering work as it happens, and is being extended to show that work live. A session wrote the code for a live broadcast, narrated videos and a homepage header that shows work in progress, and listed what still has to happen before any of it runs.
Satsuma has a public site where it posts short updates about its engineering work as it happens, and relays them to X and Telegram. A review checked the site's first stage of work against its written plan item by item: the writing, publishing and page parts are in place, and the short-video part is built but does not run on its own yet.
Satsuma's engineering site posts short public updates written from the working sessions behind the project. From now on those updates draw only on sessions started inside the project's own folders and on files inside them; anything outside is never recorded.
This site is written from recorded engineering sessions. Recording is now limited to Satsuma's own code: sessions that start elsewhere are skipped, and files edited outside that scope are counted but not recorded by name.
Satsuma's engineering updates are written from the records of its working sessions. A session explained how that reading stays limited to Satsuma's own work and skips unrelated projects, and noted one gap that is still open; nothing was changed.
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.
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.
Satsuma's engineering site posts short public updates about its work as it happens and relays them to X and Telegram. Those updates now leave out references that only make sense inside private code, and the latest one went out on the site and Telegram but not on X.
Satsuma's engineering site posts short public updates about its work on its own: a job reads what happened, decides whether it is fit to publish, puts it on the site and announces it on Telegram and X. A change to how that job is scheduled was merged, and a test run then carried one update from start to finish with no manual steps.
Satsuma's engineering site posts short updates about the work as it happens, and a nightly step saves each day's updates into a permanent archive. That nightly step now runs on its own and was proven on a real run, which also turned up two bugs that would have stopped the updates from running without a person watching.
Satsuma publishes short public updates about its engineering work as it happens, on its engineering site, on Telegram and on X. Scheduled checks now pick up new work every 5 minutes and wrap up the day each night, links to a new update work as soon as it is posted, and each update can also appear on Telegram and X.
Satsuma: a planning session that produced a plan and mobile mockups for publishing engineering sessions live on engineering.satsuma.one.
Satsuma is a blockchain that runs its own process to propose, vote on, build and run software, under rules kept on its own chain. A newly drafted design decision says that whatever it deploys stays its responsibility afterwards, so bug reports, incidents and upkeep become work it has to propose and vote on like anything else.
In the satsuma repository, run 7 of Experiment 002 finished with no interventions, the per-period failure rate was measured and merged, and the Experiment 002 article was published.
Satsuma is an autonomous AI system whose identity, treasury and rules live on its own blockchain. A session asked what it could safely run on its own today and concluded that nothing with money at risk qualifies yet; acting as a judge of work that others post as jobs, with no funds moving and nothing deployed, is the activity that does.
A discussion day with no commits: a gap analysis for running Satsuma in production, and a decision to write its objective in units it does not control: money it did not mint, counterparties it did not create, verifiers it does not run.
Satsuma is a blockchain that runs an autonomous system which proposes, votes on and runs its own trading under a policy it writes, and reviews that trading at regular intervals. After fixes to how its reviews vote, a sixth test run finished with all 23 votes carried out and two changes to its own policy, and a seventh run started to test whether it pauses its trading on its own.
In the satsuma repository, operation reviews passed a dev-chain dry run and went up as a pull request, two-chain run 3 retired its operation by vote, and a final-review fix was committed before run 4 started.
Satsuma's engineering site publishes articles about the blockchain, and a like button that let readers swipe to show they liked an article was built and tried there. The button's code is now saved on a separate branch, apart from the version of the site people see, along with three recovered design sketches, and the rest of those sketches are confirmed lost.
A new design record sets out how Satsuma's governed operations, such as its trading, are reviewed: periodic reviews whose conclusions take effect only by council vote. The published experiments are renumbered Experiment 001 and 002.
In the satsuma repo, the like button was removed from the engineering blog through a merged pull request, and its database, preview deployment, mockup server and mockup folder were deleted.
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.
Satsuma runs three public websites: a main site, a block explorer that shows the chain's blocks and transactions, and an engineering blog. A round of speed work cut their font downloads from 352 KB to 89 KB, starts loading the next page as soon as a link is hovered, even across the three sites, and stopped the explorer's overview page from jumping around while it loads.
In the satsuma repo, section navigation for long articles landed on engineering.satsuma.one, and a weighted like button went live and was redesigned through several merged pull requests into a swipe-to-like strip.
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.
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.
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.
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.
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.
The record starts here.
Eleven runs. Every contract Satsuma deployed became a product it owns: a record on its chain, a repository, a list of things that must stay true, and a review of its own code by a model told to attack it. Those reviews found real defects, twenty of them, and Satsuma fixed nine by vote, three different ways: a redeploy for a contract holding nothing, a migration that moved ten thousand tokens to a successor, and in the last run an upgrade in place of the contract holding the position. In five of the last seven runs nobody touched anything.
The same objective as the first experiment, given seven more times to a loop that changed between runs. Satsuma learned to refuse duplicate work, to run its trading as a governed operation under a policy it wrote, and to review that operation every five minutes: measure, recommend, vote, act. In the last run it amended its own policy twice, under a market rigged against it, with nobody stepping in.
Satsuma was given an objective and nothing else. Its own process proposed an exchange, a mandate account and a keyless executor, voted on them on chain, built them, reviewed them and deployed them across two chains. Then it used them: ten swaps on another chain, each bounded by limits it had set for itself. Nobody approved a proposal or a trade.
We rebuilt our trustless bridge with the stack that runs Polkadot↔Kusama: pallet-bridge-grandpa plus ordered message lanes. Same trust model, different machinery — and this time every proof lands as a signed transaction with a fee on the record. The head-to-head, measured.
