Present ALGAL's north-star vision, leading with Lisp

README.md

@@ -1,56 +1,84 @@
 # ALGAL
 
-**Write agent programs that wait, resume, and replay.**
-
-ALGAL is a programming language and VM for AI agent programs. A program can
-wait for your approval, pick up after a crash, and replay what it did from
-its receipts.
-
-The long-term direction is a substrate where these programs become durable,
-composable capabilities inside governed agent ecologies. The [vision](docs/vision.md)
-and [North Star plan](docs/north-star.md) describe that direction and the
-evidence required to earn it.
-
-Use it when an AI-assisted task needs to wait for a person, survive a CLI
-restart, reuse completed work, or explain what happened without calling the
-model again. Your host application chooses the tools and permissions; the
-program declares its decisions, limits, and approval points. A native Rust
-CLI and a Bun runtime that runs on its own implement the same specifications
-for programs, receipts, and durable processes. [algal.computer](https://algal.computer)
-has the tour, the docs, and the blog.
-
-Preview: native prereleases for macOS on Apple silicon and Linux x86_64 and
-arm64 are on the [releases page](https://github.com/hraness/algal/releases)
-(`curl -fsSL https://algal.computer/install.sh | sh`), and the Bun runtime runs
-from this checkout.
-
-From `v0.2.0-vm.13`, verified macOS and Linux installs update automatically
-within the `vm` preview channel. `algal update disable` turns automatic updates
-off; `algal update` installs a newer verified preview now. Explicit versions,
-CI, offline verification and hash-pinned SDK calls stay fixed. The Bun runtime
-keeps its existing source or package-manager update workflow. See
-[native CLI updates](docs/native-release.md#updates).
+> 🌱 ALGAL is a programming language for agent programs that outlive a single
+> run. A program can pause for your approval, resume after a crash without
+> redoing finished work, and leave receipts that replay exactly what it did.
+> Work that succeeds is kept as a typed procedure with its evidence, so the next
+> program starts from what the last one learned.
+>
+> Ask your agent to set it up: https://algal.computer
+>
+> — Ben Guo
+
+**Software that accumulates competence.**
+
+```lisp
+(program quote ((order json)) json
+  (with-total subtotal
+    (* (get order quantity) (get order unit_price))
+    (record subtotal subtotal
+            shipping (if (>= subtotal 50) 0 5)
+            total (+ subtotal (if (>= subtotal 50) 0 5)))))
+```
+
+ALGAL is a programming language and VM where a program is a value. It has a
+content-derived identity, a declared interface, and limits it cannot widen.
+A Lisp-shaped surface and the readable `.algal` source lower to the same
+manifest, so a person, a macro, or a model can write a procedure and the host
+checks it the same way. The macro expansion is printed and hashed, and all
+eleven paired programs in [the source experiment](docs/lisp-source-experiment.md)
+produce exactly the same manifest digest as their readable twins.
+
+```lisp
+(program gross ((order json)) json
+  (let gross (* (get order price) (get order quantity))
+    (let tax (* gross 0.08)
+      (record gross gross tax tax total (+ gross tax)))))
+```
+
+Programs wait for your approval for as long as it takes, resume after a crash
+without redoing finished work, and leave receipts that replay offline. When a
+procedure works, ALGAL keeps it with its evidence: a typed component any larger
+program can call by digest. Every success makes the next task start further
+along, and a fixed model works inside an environment that keeps getting more
+capable.
+
+[algal.computer](https://algal.computer) has the tour, the docs, and the blog.
+[algal.cloud](https://algal.cloud) runs ALGAL as habitats: hosted homes where
+your programs keep running, keep their receipts, and keep improving.
+
+Install the native CLI on macOS (Apple silicon) or Linux (x86_64 and arm64)
+with `curl -fsSL https://algal.computer/install.sh | sh`. Verified installs
+update automatically within the `vm` channel: `algal update disable` turns that
+off and `algal update` installs the newest verified build now. Explicit
+versions, CI, offline verification, and hash-pinned SDK calls stay fixed. See
+[native CLI updates](docs/native-release.md#updates). The Bun runtime runs from
+this checkout.
 
 ## The idea
 
-The bet behind ALGAL is that a computer can accumulate tested ways of acting,
-not only produce new answers or new code. A model proposes a bounded,
-executable procedure. The procedure is checked, measured on declared cases,
-kept with its evidence, composed into larger procedures, and revised under
-rules the host sets. Useful work should leave the computer with a more
-capable, reusable way of doing the next piece of work.
-
-Four properties of the design give that bet a testable form: an organism (an
-ALGAL program) has a content-derived identity and a declared interface, so
-successful reasoning can become a reusable component; manifests are data built
-to be generated and checked, so hand-written and model-proposed procedures
-enter through the same admission path; model judgment sits in typed cells with
-declared context and budgets, so ordinary computation supplies the discipline
-around it; and selection is a host decision recorded on the receipt, so
-provenance and permission are part of the mechanism rather than features added
-later. The mechanisms exist today. Whether accumulated procedures make later
-work measurably better than equally resourced alternatives is the open
-question. The [vision](docs/vision.md) states the bet in full and the
+A computer should be able to accumulate tested ways of acting, not only produce
+new answers or new code. A model proposes a bounded, executable procedure. The
+procedure is checked, measured on declared cases, kept with its evidence,
+composed into larger procedures, and revised under rules the host sets. Useful
+work leaves the computer with a more capable, reusable way of doing the next
+piece of work.
+
+Four properties give that idea its shape:
+
+- **Reasoning becomes structure.** An organism (an ALGAL program) has a
+  content-derived identity and a declared interface, so one program calls
+  another by digest.
+- **Procedures are data.** Manifests are built to be generated and checked, so
+  hand-written and model-proposed procedures enter through one admission path.
+- **Judgment is typed.** Model decisions sit in cells with declared context and
+  budgets, and ordinary computation supplies the discipline around them.
+- **Selection is recorded.** The host picks which successor to keep, and the
+  receipt carries the provenance and the permission.
+
+The [vision](docs/vision.md) states the loop in full: declare a responsibility,
+compile it into a bounded graph, run it with continuity, reconcile changed
+evidence, retain what improves, and carry improvements into every consumer. The
 [lineage](docs/lineage.md) places it among Lisp, Emacs, Smalltalk, Urbit,
 Engelbart, and the research on self-improving programs.
 
@@ -74,7 +102,7 @@ once the workflow proves useful.
 
 ## Try the VM with one executable
 
-Install the native prerelease into `~/.local/bin` on macOS (Apple silicon) or
+Install the native CLI into `~/.local/bin` on macOS (Apple silicon) or
 Linux (x86_64 or arm64). The script checks the archive's SHA-256 and the executable's
 recorded digest before it installs anything:
 
@@ -148,19 +176,15 @@ reading, and HTTP bodies have a deadline. Handled failures still consume the
 work budget before a recovery effect can run. See the
 [manifest and transport limits](spec/v1/organism.md) for the exact contract.
 
-### Adoption boundary
+### Your host sets the boundary
 
-ALGAL is working **prerelease software for workflows your own host application
-controls**. Native packages are unsigned and not notarized. ALGAL is an
-application VM, not an OS sandbox, so host tools keep their normal permissions.
-Coding jobs and the PR shepherd currently need the Bun host. There is no
-multi-tenant service, distributed custody (moving process ownership between
-machines), store-wide storage quota, or retention service. If a write's outcome
-is unknown, your host must confirm what happened before retrying it. A receipt
-that verifies shows the run was internally consistent; it does not show that
-its outputs are factually true or that an arbitrary external write happened
-exactly once. Read the [operating boundary](docs/use-cases.md#choose-the-right-boundary)
-before you deploy.
+An ALGAL program runs inside your application, under the tools, models, and
+limits your host grants. Tool permissions stay with the host, and a program
+cannot widen them. When a write's outcome is unknown, the process holds until
+your host confirms what happened, then continues from the receipt. A verified
+receipt shows the run was internally consistent and the effects it names were
+recorded. The [operating boundary](docs/use-cases.md#choose-the-right-boundary)
+maps each job to the host that runs it.
 
 The application lifecycle does enforce conservative [namespace byte limits](spec/v1/application.md#conservative-namespace-quota);
 they do not count shared content-addressed objects against any one application.
@@ -414,8 +438,7 @@ terminal result after a lost acknowledgement without launching the job again.
 The current delegated-coding adapter remains conservative when its outcome is unknown.
 [Native release packages](docs/native-release.md) distribute the process kernel
 for Ubuntu 24.04 x86_64 and macOS 14+ Apple silicon without Bun or Cargo. The
-repair and GitHub integration hosts still require Bun. These are qualified
-prerelease surfaces, not a claim that every provider or deployment is production-ready.
+repair and GitHub integration hosts still require Bun. 
 
 ### Grow a population of programs
 

crates/algal/Cargo.toml

@@ -4,7 +4,7 @@ version.workspace = true
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
-description = "ALGAL is a programming language and VM for AI agent programs that wait for approval and leave receipts you can replay."
+description = "ALGAL is a programming language and VM where agent work becomes typed, tested, reusable procedures that wait for approval, survive crashes, and leave receipts you can replay."
 
 [lints]
 workspace = true

crates/algal/src/main.rs

@@ -74,7 +74,7 @@ impl app_memory::MemoryAdmission for NoAdmission {
 #[command(
     name = "algal",
     version,
-    about = "ALGAL is a programming language and VM for AI agent programs that wait for approval and leave receipts you can replay."
+    about = "ALGAL is a programming language and VM where agent work becomes typed, tested, reusable procedures that wait for approval, survive crashes, and leave receipts you can replay."
 )]
 struct Cli {
     /// Skip the automatic release check for this invocation.

crates/algal/tests/cli_help.rs

@@ -31,7 +31,7 @@ fn root_help_leads_with_first_run_commands_and_hides_research_ones() {
     assert!(output.status.success());
     let help = text(&output.stdout);
     assert!(help.starts_with(
-        "ALGAL is a programming language and VM for AI agent programs that wait for approval and leave receipts you can replay.\n"
+        "ALGAL is a programming language and VM where agent work becomes typed, tested, reusable procedures that wait for approval, survive crashes, and leave receipts you can replay.\n"
     ));
     let commands: Vec<&str> = help
         .lines()

kb/launch/social-kit.md

@@ -9,7 +9,7 @@ The status is Preview. Only the last post of each thread links to the launch pos
 Post 1 of 8, 175 characters
 
 ```text
-ALGAL is a programming language and VM for AI agent programs. A program can stop before it acts, hold until you say yes, pick up after a crash, and replay exactly what it did.
+ALGAL is a language and VM for software that accumulates competence. Programs hold for your yes, resume after a crash, and replay what they did. What works is kept and reused.
 ```
 
 Post 2 of 8, 177 characters
@@ -42,10 +42,10 @@ Post 6 of 8, 122 characters
 ALGAL is for developers whose agents send messages, change code, or publish files, where one wrong action costs something.
 ```
 
-Post 7 of 8, 150 characters
+Post 7 of 8, 131 characters
 
 ```text
-ALGAL programs are data you can read, compare, and replay. The bet is that a computer can keep tested ways of working and reuse them on the next task.
+ALGAL programs are data you can read, compare, and replay. A computer keeps tested ways of working and reuse them on the next task.
 ```
 
 Post 8 of 8, 235 characters
@@ -61,7 +61,7 @@ https://algal.computer/blog/introducing-algal/
 Post 1 of 8, 175 characters
 
 ```text
-ALGAL is a programming language and VM for AI agent programs. A program can stop before it acts, hold until you say yes, pick up after a crash, and replay exactly what it did.
+ALGAL is a language and VM for software that accumulates competence. Programs hold for your yes, resume after a crash, and replay what they did. What works is kept and reused.
 ```
 
 Post 2 of 8, 177 characters
@@ -94,10 +94,10 @@ Post 6 of 8, 122 characters
 ALGAL is for developers whose agents send messages, change code, or publish files, where one wrong action costs something.
 ```
 
-Post 7 of 8, 150 characters
+Post 7 of 8, 131 characters
 
 ```text
-ALGAL programs are data you can read, compare, and replay. The bet is that a computer can keep tested ways of working and reuse them on the next task.
+ALGAL programs are data you can read, compare, and replay. A computer keeps tested ways of working and reuse them on the next task.
 ```
 
 Post 8 of 8, 235 characters
@@ -113,7 +113,7 @@ https://algal.computer/blog/introducing-algal/
 Post 1 of 8, 175 characters
 
 ```text
-ALGAL is a programming language and VM for AI agent programs. A program can stop before it acts, hold until you say yes, pick up after a crash, and replay exactly what it did.
+ALGAL is a language and VM for software that accumulates competence. Programs hold for your yes, resume after a crash, and replay what they did. What works is kept and reused.
 ```
 
 Post 2 of 8, 177 characters
@@ -146,10 +146,10 @@ Post 6 of 8, 122 characters
 ALGAL is for developers whose agents send messages, change code, or publish files, where one wrong action costs something.
 ```
 
-Post 7 of 8, 150 characters
+Post 7 of 8, 131 characters
 
 ```text
-ALGAL programs are data you can read, compare, and replay. The bet is that a computer can keep tested ways of working and reuse them on the next task.
+ALGAL programs are data you can read, compare, and replay. A computer keeps tested ways of working and reuse them on the next task.
 ```
 
 Post 8 of 8, 235 characters
@@ -163,7 +163,7 @@ https://algal.computer/blog/introducing-algal/
 ## LinkedIn post
 
 ```text
-ALGAL is a programming language and VM for AI agent programs. A program can stop before it acts, hold until you say yes, pick up after a crash, and replay exactly what it did.
+ALGAL is a language and VM for software that accumulates competence. Programs hold for your yes, resume after a crash, and replay what they did. What works is kept and reused.
 
 The demo records a proposed local publication and waits. Read the action on its report page, then approve or deny it with one command. Denying it leaves that publication undone.
 
@@ -175,7 +175,7 @@ Export a run to one file and check it on another machine with algal demo verify.
 
 ALGAL is for developers whose agents send messages, change code, or publish files, where one wrong action costs something.
 
-ALGAL programs are data you can read, compare, and replay. The bet is that a computer can keep tested ways of working and reuse them on the next task.
+ALGAL programs are data you can read, compare, and replay. A computer keeps tested ways of working and reuse them on the next task.
 
 Status: Preview. ALGAL runs on macOS on Apple silicon, and Linux on x86_64 and Arm. The free, open source demo needs no model account: install with one command, then run algal demo start.
 
@@ -197,7 +197,7 @@ Topics: Developer Tools, Artificial Intelligence, Open Source
 ## Show HN and first comment fact sheet
 
 - Write agent programs that wait, resume, and replay.
-- ALGAL is a programming language and VM for AI agent programs. A program can stop before it acts, hold until you say yes, pick up after a crash, and replay exactly what it did.
+- ALGAL is a language and VM for software that accumulates competence. Programs hold for your yes, resume after a crash, and replay what they did. What works is kept and reused.
 - The demo records a proposed local publication and waits. Read the action on its report page, then approve or deny it with one command. Denying it leaves that publication undone.
 - The demo saves its steps to disk with content fingerprints. Its report page lets you inspect the recorded inputs, proposed action and decisions together.
 - The built-in demo crashes a program twice on purpose. Finished steps are picked up, not redone. When ALGAL cannot tell whether a write went out, it stops and refuses to send it again.
@@ -208,13 +208,13 @@ Topics: Developer Tools, Artificial Intelligence, Open Source
 
 ## Beats
 
-1. ALGAL runs agent programs that stop and wait for you
+1. ALGAL is a language and VM for software that accumulates competence
 2. Review the proposed action before it runs
 3. Every step is saved as it happens
 4. Resume finished work after a crash
 5. Check a whole run on another machine
 6. For agents that touch real things
-7. The bet: software that gets better at its job
+7. Software that gets better at its job
 8. Keep host permissions explicit
 9. Try it in one command
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hraness/algal",
   "version": "0.2.0",
-  "description": "ALGAL is a programming language and VM for AI agent programs that wait for approval and leave receipts you can replay. Bun-only TypeScript package: exports and bin point at .ts sources (no build step, no Node.js support).",
+  "description": "ALGAL is a programming language and VM where agent work becomes typed, tested, reusable procedures that wait for approval, survive crashes, and leave receipts you can replay. Bun-only TypeScript package: exports and bin point at .ts sources (no build step, no Node.js support).",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/hraness/algal.git"

site/blog/introducing-algal.md

@@ -2,15 +2,26 @@
 title: "Introducing ALGAL"
 order: 1
 date: 2026-09-29
-description: Language and VM for agent programs that wait for approval and resume.
+description: A language and VM where agent programs wait, resume, and compound into reusable skill.
 eyebrow: Launch
-cardDescription: "ALGAL runs agent programs that stop for your yes, survive a crash, and replay what they did."
+cardDescription: "Agent programs that hold for your yes, survive a crash, and compound into reusable skill."
 updated: 2026-10-05
 ---
 
 # Introducing ALGAL
 
-Start with a local approval task: inspect a proposed publication, approve or deny it, then replay its saved history. The built-in demo shows how an agent program can wait and recover while the host keeps control of its actions.
+```lisp
+(program quote ((order json)) json
+  (with-total subtotal
+    (* (get order quantity) (get order unit_price))
+    (record subtotal subtotal
+            shipping (if (>= subtotal 50) 0 5)
+            total (+ subtotal (if (>= subtotal 50) 0 5)))))
+```
+
+ALGAL is a language and VM where a program is a value: it has a content-derived identity, a declared interface, and limits it cannot widen. Programs wait for your approval, resume after a crash, and leave receipts that replay offline. The ones that work are kept with their evidence and called by digest from larger programs, so each task starts further along than the last.
+
+The built-in demo starts with a local approval task: inspect a proposed publication, approve or deny it, then replay its saved history.
 
 {{LAUNCHFILM}}