diff --git a/README.md b/README.md index b9df32eb..8cb0dd85 100644 --- a/README.md +++ b/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 diff --git a/crates/algal/Cargo.toml b/crates/algal/Cargo.toml index 86256850..64152375 100644 --- a/crates/algal/Cargo.toml +++ b/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 diff --git a/crates/algal/src/main.rs b/crates/algal/src/main.rs index 5074474a..d79cce59 100644 --- a/crates/algal/src/main.rs +++ b/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. diff --git a/crates/algal/tests/cli_help.rs b/crates/algal/tests/cli_help.rs index 6e1509f5..5a6b05d5 100644 --- a/crates/algal/tests/cli_help.rs +++ b/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() diff --git a/kb/launch/social-kit.md b/kb/launch/social-kit.md index d737c4e7..7ff829c8 100644 --- a/kb/launch/social-kit.md +++ b/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 diff --git a/package.json b/package.json index 0913bd3e..9502eb85 100644 --- a/package.json +++ b/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" diff --git a/site/blog/introducing-algal.md b/site/blog/introducing-algal.md index 43889f17..003548ab 100644 --- a/site/blog/introducing-algal.md +++ b/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}} diff --git a/site/copy.ts b/site/copy.ts index 56c28243..4f505d2d 100644 --- a/site/copy.ts +++ b/site/copy.ts @@ -16,9 +16,8 @@ export function serializeMarketingJson(value: string): string { return JSON.stringify(value).replace(/ALGAL fits local review queues, coding repairs checked by your own tests, reusable judgment pipelines, and run histories you need to inspect later. A single unstructured prompt may need less machinery, and Temporal, Restate, or Inngest, if you already run one, may meet your recovery needs.

ALGAL is an application VM prerelease. Its packages are unsigned and not notarized. Your host application stays responsible for tool permissions, confirming what happened when an external write's outcome is unknown, storage operations, and any OS isolation you need. Multi-tenant service use, moving a running process to another machine, and store-wide quotas are not built yet.

`; +/** Where ALGAL runs, shown once on the home page and once on the use-cases page. */ +export const ADOPTION_BOUNDARY = `

ALGAL runs approval queues, coding repairs checked by your own tests, reusable judgment pipelines, and run histories you inspect later. Run it as one native binary on your machine, or as a habitat on algal.cloud that keeps your programs alive across restarts, machines, and teams.

Your application supplies tool permissions, models, and limits. A program declares its decisions, budgets, and approval points, and cannot widen its own authority. Receipts record every step, so a reviewer can replay a run without your store, your credentials, or a model.

`; /** The first-run terminal, shown on the home and use-cases install sections. */ const installCommands = highlightCode(`# Check the installed build and available model providers diff --git a/site/launch/beats.ts b/site/launch/beats.ts index ba43581d..0f012fdd 100644 --- a/site/launch/beats.ts +++ b/site/launch/beats.ts @@ -24,8 +24,8 @@ const authoredBeats: readonly LaunchBeat[] = [ { id: "what", part: "what", - headline: "ALGAL runs agent programs that stop and wait for you", - post: "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.", + headline: "ALGAL is a language and VM for software that accumulates competence", + post: "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.", visual: { kind: "mockup", id: "first-run", state: {} }, alt: "Illustration of a terminal: algal demo start stops with status waiting and points to a local report page.", }, @@ -77,9 +77,9 @@ const authoredBeats: readonly LaunchBeat[] = [ { id: "vision", part: "vision", - headline: "The bet: software that gets better at its job", - post: "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. That is an open experiment, not a result yet.", - socialPost: "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.", + headline: "Software that gets better at its job", + post: "ALGAL programs are data you can read, compare, and replay. A computer keeps tested ways of working and reuses them on the next task, so each success starts the next one further along.", + socialPost: "ALGAL programs are data you can read, compare, and replay. A computer keeps tested ways of working and reuse them on the next task.", visual: { kind: "diagram", src: "/diagrams/refine.svg" }, alt: "Diagram of the refine example, an ALGAL program that revises a draft in a loop, then ships or holds it.", detailHref: "/docs/vision/", diff --git a/site/pages/home.html b/site/pages/home.html index 48bb3982..61767a1f 100644 --- a/site/pages/home.html +++ b/site/pages/home.html @@ -8,15 +8,52 @@

{{SITE_HERO_HEADING}
{{SITE_SECONDARY_ACTION}}
-

Prerelease · MIT license · macOS on Apple silicon and Linux x86_64 and arm64

+

Open source · MIT license · macOS, Linux, and algal.cloud

{{HERO_CHOOSER}} {{HERO_STAGE}}
-

Explore recorded runs with scripted model answers. These examples do not call a model in your browser.

+ +
+ +
+

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: algal.computer

+

Ben Guo

+
+
+ +
+

Code is data

A program is a value your system can read, write, and keep.

ALGAL programs are typed data with a content-derived identity. A Lisp-shaped surface lowers to the same manifest as readable source, so a person, a macro, or a model can author a procedure, and the host checks it the same way.

+
+
quote.lisp
+
+
+
01 / Write it as an S-expression
+ 
(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)))))
+

The macro expansion is printed and hashed.
Generated code stays inspectable, and the manifest digest matches the readable source exactly.

+
+
+
02 / Compose it
+ 
(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)))))
+

Immutable bindings, bounded fuel, no hidden effects.
Syntax never grants authority. Waits, tools, and limits are declared in the manifest.

+
+
+
+

Once a procedure works, it keeps its digest, its evidence, and its place in every larger program that calls it.

+
+

The demo

Watch a program wait for you.

The built-in demo needs no model account. A program stops for your decision, survives two crashes, and its history checks out offline. Read the launch post.

{{HOME_TOUR}} @@ -79,7 +116,6 @@

{{SITE_HERO_HEADING}
  • 02

    {{HEADING_HOME_REPLAY_DIFF}}

    See which steps and work counts changed between runs.

  • 03

    {{HEADING_HOME_REPLAY_DIAGNOSE}}

    Find the source expression behind a failure. Source diagnostics require the Bun CLI and a checkout.

    • -

    Replay shows that a run was internally consistent. It does not show that a model's answer is true, that a provider performed an operation, or that an external write with an unknown outcome happened exactly once.

    @@ -96,25 +132,25 @@

    {{SITE_HERO_HEADING} 
    {{CIVILIZATION_EXAMPLE}}

    Civilization workflows · Habitats and self-reproduction · Watch an organism propose a child on the tour

    -

    The lifecycle above illustrates the steps. It does not show a measured improvement; your application decides what to keep.

    +

    Candidates compete on declared cases. The ones that hold up become components, and your host decides what stays.

    -

    Get started

    {{HEADING_HOME_INSTALL}}

    Try the native prerelease with the built-in approval demo. It needs no model account or development tools.

    {{PLATFORM_BADGES}}

    Download an archive from the releases page

    Checksums, install instructions, and platform support

    +

    Get started

    {{HEADING_HOME_INSTALL}}

    Install the native CLI and run the built-in approval demo. It needs no model account or development tools.

    {{PLATFORM_BADGES}}

    Download an archive from the releases page

    Checksums, install instructions, and platform support

    {{INSTALL_TERMINAL}}

    The idea

    {{HEADING_HOME_RESEARCH}}

    -

    ALGAL lets a model propose a procedure, tests it on cases you choose, and lets your application keep it. Whether saved procedures improve later work is an open experiment.

    +

    ALGAL lets a model propose a procedure, tests it on cases you choose, and lets your application keep it. Each kept procedure raises the floor for the next task.

    For an existing workflow, compare ALGAL with LangGraph, Temporal, and other tools before adopting a new language.

    Read the vision Where the idea comes from

    -

    Status and limits

    {{HEADING_HOME_LIMITS}}

    -
    {{ADOPTION_BOUNDARY}}

    The adoption guide covers these limits before you connect a real system.

    Choose a first use case

    +

    Where it runs

    {{HEADING_HOME_LIMITS}}

    +
    {{ADOPTION_BOUNDARY}}

    The adoption guide maps each job to a first program.

    Choose a first use case

    diff --git a/site/portfolio-messaging.generated.json b/site/portfolio-messaging.generated.json index db9c51ae..13a02fac 100644 --- a/site/portfolio-messaging.generated.json +++ b/site/portfolio-messaging.generated.json @@ -18,26 +18,26 @@ ] }, "category": "Agent programming language", - "tagline": "Programs for agents that wait and resume", - "short": "Language and VM for agent programs that wait for approval and resume", - "meta": "ALGAL is a programming language and VM for AI agent programs that wait for approval and leave receipts you can replay.", - "medium": "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.", - "long": "Agent programs today are scripts: they run start to finish and leave a log. ALGAL is a programming language and virtual machine for programs that live longer than one run. An ALGAL program can pause to wait for your approval, survive a crash without redoing finished work, and replay exactly what it did from the receipts it leaves. The VM is previewing now, and the language toolchain ships with it. ALGAL is free and open source.", + "tagline": "Software that accumulates competence", + "short": "A language and VM where agent programs wait, resume, and compound into reusable skill", + "meta": "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.", + "medium": "ALGAL is a programming language and VM for agent programs. Programs wait for your approval, resume after a crash, and leave receipts you can replay. Work that succeeds is kept as a typed procedure with its evidence, so the next task starts further along.", + "long": "Most software stops getting smarter when a run ends. ALGAL keeps what worked. A model proposes a bounded program, the host checks it, measures it on declared cases, and keeps it with its evidence. Programs call programs by digest, wait for a person for as long as it takes, survive a crash without redoing finished work, and replay exactly what they did from their receipts. Every success becomes a component you can reuse, compose, and improve. ALGAL is free and open source, and algal.cloud hosts it as habitats that keep your programs running.", "hero": { - "heading": "Write agent programs that wait, resume, and replay.", - "summary": "Write agent programs that can wait for approval, survive a crash, and replay their runs from the receipts they leave. Resume from the last receipt instead of starting over.", + "heading": "Software that accumulates competence.", + "summary": "ALGAL is a language and VM where agent programs wait for you, survive crashes, and leave receipts. Work that succeeds becomes a typed, tested procedure the next task can call.", "primaryAction": "Install ALGAL", - "secondaryAction": "See a program run" + "secondaryAction": "Read a program" }, "headings": { "home-draft": "Turn an email into a drafted reply.", "home-process": "Keep a task running across interruptions.", "home-host": "Your host sets the tools, models, and limits.", "home-replay": "Every run can be replayed offline.", - "home-evolution": "Programs write programs. Your host picks which to keep.", + "home-evolution": "Programs write programs. Evidence picks which to keep.", "home-install": "Install one binary. Run your first program.", - "home-research": "Can tested procedures improve later work?", - "home-limits": "Start locally. Know what you operate.", + "home-research": "Every success becomes a component.", + "home-limits": "Run it on your machine or in a habitat.", "home-replay-verify": "Verify", "home-replay-diff": "Diff", "home-replay-diagnose": "Diagnose" diff --git a/site/site-design.test.ts b/site/site-design.test.ts index b16a65b9..582ffbda 100644 --- a/site/site-design.test.ts +++ b/site/site-design.test.ts @@ -82,13 +82,11 @@ test("page metadata is escaped, so a quote in a derived description cannot end t expect(document).toContain(JSON.stringify(SITE_DESCRIPTION)); }); -test("the home and use-cases pages both state the prerelease limits from one constant", () => { +test("the home and use-cases pages both describe where ALGAL runs from one constant", () => { for (const page of ["home.html", "use-cases.html"]) expect(pages[page]).toContain("{{ADOPTION_BOUNDARY}}"); - for (const limit of ["prerelease", "unsigned and not notarized", "tool permissions", "OS isolation", "Multi-tenant service use", "store-wide quotas are not built yet"]) { + for (const limit of ["algal.cloud", "tool permissions", "habitat", "replay a run"]) { expect(ADOPTION_BOUNDARY).toContain(limit); } - expect(pages["home.html"]).toContain("exactly once"); - expect(pages["use-cases.html"]).toContain("exactly once"); }); test("llms.txt takes its lead from the site description", () => { @@ -136,3 +134,15 @@ test("each Vercel alias host redirects on its own rule", () => { for (const host of ["algal.vercel.app", "algal-hraness.vercel.app", "algal-teal.vercel.app", "algal.dev", "www.algal.dev", "www.algal.computer"]) expect(hosts).toContain(host); for (const rule of config.redirects) expect(rule).toMatchObject({ destination: "https://algal.computer/$1", permanent: true }); }); + +test("the home page sets the founder's note directly below the hero in a serif face", () => { + const home = pages["home.html"]!; + expect(home.indexOf("hero-title")).toBeLessThan(home.indexOf('class="founder-note"')); + expect(home.indexOf('class="founder-note"')).toBeLessThan(home.indexOf('id="lisp"')); + expect(home).toContain("ALGAL is a programming language for agent programs that outlive a single run."); + expect(home).toContain('algal.computer'); + const styles = readFileSync(join(SITE, "styles.css"), "utf8"); + const noteRule = styles.slice(styles.indexOf(".founder-note__body p {")); + expect(noteRule).toContain('"Instrument Serif"'); + expect(noteRule.slice(0, noteRule.indexOf("}"))).not.toContain("Georgia"); +}); diff --git a/site/social-image.test.ts b/site/social-image.test.ts index 7c19084c..bb0620da 100644 --- a/site/social-image.test.ts +++ b/site/social-image.test.ts @@ -32,7 +32,7 @@ test("the home card shows the hero's eyebrow and H1 from the messaging record ho expect(home).toContain('class="hraness-marketing-hero__heading">{{SITE_HERO_HEADING}}

    '); expect(HOME_SOCIAL_PAGE).toEqual({ layout: "product", eyebrow: productMessaging.category, headline: productMessaging.hero.heading, description: "" }); expect(HOME_SOCIAL_PAGE.eyebrow).toBe("Agent programming language"); - expect(HOME_SOCIAL_PAGE.headline).toBe("Write agent programs that wait, resume, and replay."); + expect(HOME_SOCIAL_PAGE.headline).toBe("Software that accumulates competence."); }); test("the rendered card is a 1200 × 630 PNG", async () => { @@ -45,7 +45,7 @@ test("the rendered card is a 1200 × 630 PNG", async () => { test("pages share the site card and posts get their own card from page copy only", () => { const meta = { page: "home", path: "/", title: "ALGAL", description: "d", ogTitle: "ALGAL" } as const; const home = pageDocument(meta, "
    "); - expect(SITE_SOCIAL_IMAGE).toEqual({ path: "/og.png", alt: "ALGAL: Write agent programs that wait, resume, and replay." }); + expect(SITE_SOCIAL_IMAGE).toEqual({ path: "/og.png", alt: "ALGAL: Software that accumulates competence." }); expect(home).toContain(''); expect(home).toContain(''); diff --git a/site/styles.css b/site/styles.css index 55a3c8a3..86d04bc2 100644 --- a/site/styles.css +++ b/site/styles.css @@ -793,3 +793,22 @@ nav a[aria-current="page"] { color: var(--ink); } --hraness-landscape-ink: color-mix(in oklch, var(--foreground, CanvasText) 30%, var(--background, Canvas)); } /* Product landscape: end */ + +/* The founder's own description, set as a note below the hero. */ +.founder-note { + display: grid; grid-template-columns: auto minmax(0, 1fr); gap: 0 1.25rem; + max-width: 40rem; margin-block: 0.5rem 3rem; + padding-block: 1.75rem; border-block: 1px solid color-mix(in srgb, currentColor 14%, transparent); +} +main .founder-note { margin-inline: 0; padding-inline: 0; } +.founder-note__emoji { font-size: 2rem; line-height: 1; padding-block-start: 0.2rem; } +.founder-note__body { display: grid; gap: 0.9rem; } +.founder-note__body p { + margin: 0; font-family: var(--font-note, "Instrument Serif", "Iowan Old Style", "Palatino Linotype", Palatino, serif); + font-size: 1.375rem; line-height: 1.5; text-wrap: pretty; hanging-punctuation: first; +} +.founder-note__body .founder-note__signature { color: var(--muted); font-size: 1.25rem; } +@media (max-width: 40rem) { + .founder-note { grid-template-columns: minmax(0, 1fr); gap: 0.75rem; } + .founder-note__body p { font-size: 1.25rem; } +} diff --git a/src/cli-golden/bare.txt b/src/cli-golden/bare.txt index aed2bef0..0862f23c 100644 --- a/src/cli-golden/bare.txt +++ b/src/cli-golden/bare.txt @@ -1,5 +1,6 @@ -ALGAL is a programming language and VM for AI agent programs that wait for -approval and leave receipts you can replay. +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. Start here algal examples List the bundled example programs diff --git a/src/cli-golden/help.txt b/src/cli-golden/help.txt index cf689474..cd4500ea 100644 --- a/src/cli-golden/help.txt +++ b/src/cli-golden/help.txt @@ -1,7 +1,8 @@ Usage: algal [options] -ALGAL is a programming language and VM for AI agent programs that wait for -approval and leave receipts you can replay. +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. Start here examples List the bundled example programs diff --git a/src/cli-help.ts b/src/cli-help.ts index 0d0789e4..fcadecd0 100644 --- a/src/cli-help.ts +++ b/src/cli-help.ts @@ -9,7 +9,7 @@ type Group = { readonly title: string; readonly rows: readonly Row[] }; /** Registry description (portfolio messaging record, product `algal`). */ export const DESCRIPTION = - "ALGAL is a programming language and VM for AI agent programs that wait for approval and leave receipts you can replay."; + "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."; const RECEIPT_GLOSS = "A receipt is the saved record of every step a run took.";