Repository navigation
Releases
altitude v0.9.5
Remotes
A task that runs on a host starts with its project's cache already mounted: the remote lends one project's cache to the one host that needs it, and takes the lend back when the sandbox ends. What serves it is a small unit on the remote rather than something altitude runs with privilege, so handing out a cache no longer needs a grant — and the mount a host makes is the same one it always made.
A host says what it is doing while it provisions. Its own words are the status line, and its log reaches the remote as it goes, so a provision that spends minutes building a layer reads as work rather than as a host that died — and a host that fails leaves its reason behind instead of a timeout. A call that breaks halfway through asks the host whether the sandbox exists before deciding the task failed.
Tasks and agents
A task that never reached its first turn says it could not start, rather than reporting that altitude stopped it.
Isolation
The port relay's helper is written inside the sandbox's own home instead of /usr/local/bin, which on a real host belongs to the machine and not to the sandbox. Without that, a task on a host could not start at all.
Elsewhere
The worker image takes an NFS client rather than /dev/fuse, and the source tree is grouped by the part of the system each file belongs to, so the files that answer a question sit together.
altitude v0.9.4
Full Changelog: v0.9.3...v0.9.4
altitude v0.9.3
Full Changelog: v0.9.2...v0.9.3
altitude v0.9.2
Full Changelog: v0.9.1...v0.9.2
altitude v0.9.1
A host no longer rebuilds the software a task expects, the two conversations that cross
machines now dial what they actually speak, and the command that asked an operator to
do the rebuilding is gone.
Hosts and workers. The agent and version-control layer is built once by the first
host of an image and left on its master; the hosts that follow restore it instead. A
turn on a warm host is the project's own setup and nothing else. What a host is has to
be declared — ALTITUDE_WORKER_ENVIRONMENT — because a layer built on one image is not
the software another image's hosts expect.
Remotes. A master asked a host for a sandbox, and a host asked for its project's
cache, over the link's protocol. Both were refused at the handshake by an endpoint that
only accepts its own, so the worker fleet and the mounted cache could not have worked
between two machines. Each conversation has its own ALPN now.
Interface. altitude serve environment is gone: what it printed is what a host
does by itself. The worker guide says the one line an operator still writes, and what
an image has to carry.
altitude v0.9.0
Remotes
A remote can hand its tasks' sandboxes off its own machine. Give it two scripts and a
ceiling in serve.toml and it provisions a disposable host per sandbox, runs the task
there, and destroys it when the sandbox ends — the task store, the scheduler and the
tracker stay where they were. The host runs as an ordinary user rather than root, so it
can be a pod on a platform that will not give it a privileged process, and it mounts the
remote's project cache instead of copying it, so a build on a throwaway machine reads and
writes the cache that lives on the remote. A task that parks keeps its work: the host
archives the sandbox before it goes and the next one restores it, so waiting on you no
longer means starting over from the repository. A profile's setup now builds what a task
will actually see — the same mounts, the same ~ — and asks for no privilege, so what a
project installs lands where the task reads it rather than beside it. altitude serve worker --help is the whole setup guide, including what a host image has to carry and how
to bake the layers a start would otherwise rebuild: an image that names itself with
ALTITUDE_WORKER_ENVIRONMENT keeps the layers it built, and a new image gets new ones.
The repository's Dockerfile has a worker target to start from.
Isolation
A sandbox's memory is promised rather than measured: a ceiling is taken when the sandbox
is made and released when it goes, and what is outstanding is bounded, so a second and a
third delegation are no longer handed memory the machine has already spent. A workspace
now starts from the Node image rather than Ubuntu — minutes off a first start, and a
different base for every project's setup command to be written for. A mount says how much
room it needs, so a build is not refused at four gigabytes.
Tasks and agents
A thread's kind is named for what it wants from you, a blocking question or a
ready-for-review, and closing one is one act wherever it is closed. A reply is not a
hand-back: raising the thread is, so an agent that says what it is doing no longer stops
the task by saying it, and a thread opened by mistake is the agent's to close rather than
yours. An acceptance is announced where it happens, so a task completed in Linear leaves
the list on every machine watching it; a message that reaches a running task is reported
as forwarded rather than read back out of the tracker afterwards; and a task put back to
work joins the queue rather than starting a turn where it stands.
Tracker
A refused write to an issue is said again next pass instead of forking the conversation
into a second session, and a task waiting on you names you. A remote no longer tells you
it holds no login of yours when the sign-in was the provider's own, so delegated work
starts on a fresh setup rather than waiting for a second one.
Settings and projects
A machine you have not used before no longer means signing in again to everything that
was already signed in: where an agent or version-control login is on the host, onboarding
and settings offer to import it, naming where its tool keeps it and asking first, because
reading another tool's directory is reading your machine. Imported, it becomes the profile
the next task mounts.
altitude v0.8.0
Interface
A task's threads are its history: every ask it has made, newest first under the day
it was asked, with the open one at the top. The activity takes the height and the
plan sits under it, and what the agent is thinking runs in that stream dimmed rather
than behind a key — as does altitude's own news, a pause, a lost machine, an
acceptance — so a task that stopped no longer reads as a stream that went quiet. A
diagram in a report draws where it was written, across the column, while keys keep
answering, and arrives with its words given room: boxes clear of their text, arrows
straight, and an edge label that would have been buried under a box moved out of it.
Tasks and agents
One ask is open at a time. Any thread closes or reopens — here or in Linear — as one
act whether it was a question or a review; closing the question a task was waiting on
starts the work it was holding; and an ask the operator has moved past is replaced
when the agent has a new one instead of staying open beside it. A restart resumes the
turn the shutdown pause hid.
Tracker
An issue has one session, and a task that replaces another joins it rather than
opening a second thread about the same work. An answer is posted into the thread it
answers, a comment or a reaction on the issue reaches the task as the operator's own
act, and a thread resolved in Linear closes here and frees a task waiting on it.
Projects
A project remembers what its tasks learned: a folder of markdown that every task of
the project reads, edits and greps with qmd, and that follows the work between
machines. altitude's own notes in it are read-only, so the instructions an agent
reads are not the ones it can rewrite.
Isolation
A sandbox may grow to thirty gigabytes, and a build step can no longer wait for ever.
ALTITUDE_ISOLATION=testbed runs altitude inside one of its own sandboxes, for
exercising a task end to end where there is no microVM.
altitude v0.7.2
altitude 0.7.2
A turn ends with the signal it raises, a task moves between machines in about a
second per side, and a busy machine says why.
Tasks and agents
A turn now ends with the signal it raises, and Altitude resumes whenever nothing
of yours is waiting on the operator — so a task circles less and each turn costs
one model call instead of two. A held review wakes the agent only when a pull
request moved, and says what moved. A task that stops reads as stopped, FAILED
with its reason, instead of a thread that looks like a question. A start that
stops making progress is ended and reported rather than holding the queue.
Remotes
Moving a task between machines is several times faster, and every tree is checked
on both sides, so a transfer that lost a file ends rather than arriving short. The
tracker says what a remote is doing with a delegated task, with age: queued,
starting, and which environment step it is on.
Interface
Alt-S opens a shell in the sandbox during a take-over; ctrl-q hands the task back
from either.
Isolation
Environments build in layers, so editing a project no longer rebuilds its
toolchain, and a machine answers whether it is coping rather than how many
sandboxes fit.
Tracker
A task that stopped no longer looks like a working agent to Linear, and a
delegation that is declined says why.
Upgrading
Upgrade every machine together: the task capsule's layout changed, so a transfer
in flight across versions will not resume.
altitude v0.7.1
Upgrading from 0.7.0
0.7.0 would not start on a settings file that names a login by its service alone
(agents/pi, vcs/github, trackers/linear — what a 0.6 file, or any file written
before identities had names, holds). It stopped at boot with credential "agents/pi"
is not a usable named identity and ran with no settings at all. Those files are read
as they stand now. Nothing to edit, nothing to migrate.
A machine pushed that configuration kept answering unknown credential profile: the
same check runs on the other side of the link, so the remote needs this build too.
Both machines on 0.7.1 and the push goes through.
Settings and projects
- A login named by its service alone is a login like any other.
agents/piis
the Pi login, not a broken identity, and Settings lists the identities a 0.6 file
holds instead of hiding them. - Identities on disk are found by their names, not only by their service. A
settings file that lost its credentials used to resurrectagents/piand drop
agents/claude/claude-code; it now finds every profile directory that is a login. - Choosing a harness finds its login even when you named it. Picking Claude with
one Claude account used to leave the credential "not chosen" with the account
sitting right there; two accounts are still two to choose between.
Remotes
- A refused configuration says what to act on. The machine that refuses names the
login it does not know, and the client names the machine and the version it runs,
instead of reporting that it "did not answer" when it plainly did.
Isolation
- The sandbox image's progress bar is gone. One line under the phase carries the
measurement —42% · 1.2 GB of 2.6 GB · 18.4 MB/s— and it appears when the first
byte moves, so an image that is already downloaded no longer sits on0%. - Installing the base packages counts. apt announces how many packages it will
add and dpkg names each one as it configures it, so the boot screen now says
12 of 31while it works instead of a phase that sat still. The setup itself is
unchanged: nobody rebuilds a base snapshot for this.
Interface
- The task list's footer names the right key for settings. The ranked table moved
Settings to,and gavesto the sort menu; the footer kept sayings, so the
key it advertised opened a menu and the real one appeared nowhere on screen.
Internal
Service::ownsis now the one place that decides which service a credential id
belongs to, and what it accepts is exactly what the id writers emit — the drift
between the two that 0.7.0 shipped is the bug above.
altitude v0.7.0
Signals worth reading
- A signal body is drawn as markdown: headings, lists, quotes, code, and tables that get a grid of their own instead of running into a paragraph. The agent is told its bodies are drawn this way, so what it writes as a table arrives as a table.
- A mermaid fence becomes a diagram drawn inside the card that carried it, scaled to the column and to the words around it, and never taller than forty rows.
- A picture in a message is drawn in the terminal — kitty, sixel or iTerm2 — where the terminal can draw one. Where it cannot, the source is shown instead, because a diagram is mostly its labels.
- A picture raised on another machine is fetched by its digest, and one posted in a signal reaches the issue as a picture, in the comment that named it.
- A picture nothing names anymore is cleared at startup, instead of being kept for the life of the data directory.
The task list
- The card grid is a table on an even grid — title, signals, issue, pull requests, age — reading across the whole window instead of crowding the border.
- Rows are grouped by the most urgent thread that is still open: failed, needs you, ready to review, decisions, info, working, queued, limited, paused, done. A group folds from its own heading.
- The signal count says what is waiting by kind (
?1 →5 ○35), because a task asking a question and a task reporting progress are looked at at different times. A task with nothing but reports is filed with the work it reports on.
Tracker
- The issue's thread carries what the agent says and thinks as it happens: a line per thought, permanent, so the session reads as a transcript rather than one line changing under the operator. Tool calls stay out of it.
- The pickup line names whose agent it is — "Gaby's Pi is picking up this task" — instead of leaving the operator out of a sentence about their own work.
- A message from the issue steers the running agent, the way a message typed into the task does. It no longer stops the run, throws the sandbox away and builds it again four seconds after you commented.
- A reply is answered once, by the run that follows it, rather than by every run from then on.
- The first run of a session says who picked the task up, permanently. A task that waited is no longer stuck under the ephemeral queue notice that the run it started never replaced.
Remotes
- A first start says which part it is on — installing the runtime, pulling the base image with the bytes it has moved, building the project's environment — and a client waiting on that machine reads the announcement again rather than sitting on the word it was given.
- A watched task's activity travels with its card, so a task running on another machine shows what the agent is doing and not only its plan. What travels is the newest line, not the run's history; the terminal is still the record.
- A machine owed nothing no longer reads "sending setup…" for as long as the application runs. The row says there is nothing to send, that a task is still holding its copy, that a configuration is on its way, or that it is up to date.
Tasks and agents
- A usage limit no longer fails a task. It pauses with a clock, gives its sandbox slot back so the wait costs no room, and comes back on its own when the window reopens — by the admission pass that already runs every ten seconds, not by you replying. The issue's session says what happened, once, and the details line says which window ran out and the hour it lets go.
- Only Claude Code reports its account's windows today. Pi reports what a run cost and nothing about its account, so a pi task is not paused on a limit and does not resume itself.
- A refusal that is not a window — no credits, or a limit with no time on it — is still yours, and it says what the account said rather than that the command was rejected.
- A task says what it has spent, in its harness's own accounting. Altitude prices nothing itself, and on a subscription the figure is hidden: a plan's turns are priced at list rates whether or not anything is being paid.
- What the agent is doing is on its card while it runs: the tool it started, the file or command that tool is aimed at, and the words around it. Pi and Claude Code both report it, and it is dropped when the run ends.
- The activity stream is what the agent says and thinks, not its shell. A shell command's text is gone — the line reads
using <tool>— and the reasoning the harness streams beside its messages is there, marked as thinking. - A harness is pinned by major, so an environment refresh cannot hand back the same three-week-old harness. Claude Code's stable pointer must still be 2.x or the build stops instead of arriving unannounced in a sandbox.
Interface
- The task screen shows what the agent is doing, under the plan, as it arrives: the newest line bright, the older ones dim, scrolling on the wheel and the keyboard the way the signal threads do, keeping the last two hundred lines.
- The plan and the activity hold half the column each, both titled and both scrollable, and the activity keeps its half when it is empty so the column does not change shape under the reader when a run starts.
- A focused pane shows a rail and its name. The focus ring is built from what the screen actually drew, so it cannot stop on a pane that is behind a tab, and a focus whose pane went away falls back to the list.
- The boot screen shows the base image download with a percentage and the bytes moved, and it keeps painting with animations turned off.
Settings and projects
- A credential is named one way everywhere. The list of services is read from the kinds that own them rather than kept a second time beside them, and the difference you see is a credential called "Claude" in the interface, the way a task row already called it.
Internal
- One contract and the things that answer it are a
providers/folder:agent,tracker,vcsandisolationeach state a trait in the folder above and keep the implementations beside it. - The files that had more than one job are folders named for the jobs, and no method changed on the way out: the app is twenty-three files beside an
input/folder with one file per screen it answers, the run loop is control, lifecycle, transfer, review, watching, admission and terminal, the remote host is task host, tracker host, transfer and run, the tracker host is intake, delegation, answering, reporting, delivery and records, the signals screen is frame, plan, threads and conversation, the isolation runtime is base, snapshot, lifecycle, files and engine, the sandbox is profile, plan, guest and run, the store is events, reports and signals, and Linear's client is queries, issues, comments, sessions and agent sessions. utilsisshimmerandformat, because that is what was in it.- A preview harness for looking at the interface without asking real agents to run:
scripts/demo.pywrites a throwaway home of fabricated tasks covering every group of the list, andALTITUDE_PREVIEW=1draws that list with no task service behind it (a release build needs--features preview). - Dependencies: pulldown-cmark 0.13, mermaid-rs-renderer 0.3, resvg 0.49, image 0.25, ratatui-image 11.1.