Alelyon app 0.8.0, the patch notes.

Alelyon app 0.8.0 24 October 2026

• alelyon-cli tools --json prints the Pages tools (names, routes, scopes, descriptions, hints and input schemas), the same tools Alelyon's hosted MCP server offers.
• Friends chat in the app takes its message chain, its warnings and safety codes from alelyon-social-core, the crate the website runs as WebAssembly, so both clients compute them from one source; nothing a person sees changes.
• alelyon-cli prints the request id Alelyon answered with when a call is refused, to quote or to find in the developer console.
• Friends chat in the app checks every message's place, as the website does: a missing, repeated, reordered or swapped message is said under it; a friend's new device waits for Accept; the safety code (the same twelve groups as on the website) can be marked verified, and a change holds sending until you compare again.
• Links in Friends chat and in Pages, and a product's website and source, open only after a check on this PC: pressing one shows the site it really goes to, the address in full, and anything about it that deserves a second look (words that hide the site before an @, a name that passes for Alelyon's, letters from other alphabets, a program download, a numeric address, a short link, a very long name, or no encryption), with Open, Copy address and Cancel. The check reads the address only, never sends it anywhere, and is the same code the website runs. Esc closes it.
• Pages: Check signature, in every post's ⋯ menu, checks the post on this PC against its page's key and says whether it is what the page published, unchanged, in the website's words. The check runs in alelyon-social-core, the same code the website's Friends chat runs. My page's Privacy tab downloads your page's signed repository as one file to your Downloads folder, with Show in folder.
• The developer console's analytics have a Rust core for the app: time ranges, the identity service's series, latency percentiles and Apdex, the levels, the words, and the findings (error and latency spikes, quiet stretches, drops and surges). They are held to the website's own answers, case by case. Nothing in the app shows them yet: the console panel comes with the Atlas layout.
• alelyon-cli notify tells your phones from any harness (question, finished, failed, ready or test, with a short title), with a developer token that has the notify:send scope; for your agent, the MCP tool notify. Its README shows Claude Code hooks that tell your phone when it needs you or stops.
• Agents' dashboard reads (alelyon.dashboard/1) pin what clients rely on: level and attention are closed sets; series is {what, values}; each tile says when it was read (read_at); an unknown tile is a 404 unknown-tile with the section's tiles.
• Dashboards arrange themselves (groups, what needs a look first, tiles sized to content, no gaps, nothing cut; Needs a look line); Models and Research open on dashboards; the agent bridge serves every dashboard to the person's agent (dashboards, dashboard: alelyon.dashboard/1), Fleet through Section::dashboard.
• Fleet, Lattice, Transcription and Compute open on a dashboard instead of a row of tabs: one tile per part with its key figures; press a tile for its full view (← Dashboard goes back); Arrange to drag, size (S/M/L), add, remove or reset tiles, kept in preferences (centcom::dashboard). A tile can still get a window of its own (drag it off, middle-click it, or Own window).
• Settings, Agents: with Let my agent drive Alelyon on, the lines that connect Claude Code (claude mcp add) or Codex (its config.toml) to alelyon-cli, with its full path and a Copy button each, once alelyon-cli is built (the install steps now build it too).
• Internal: the panel API Atlas's panels are built on (no visible change).
• Development records only: CENTCOM's README Checked list moved to docs/audits, and lattice-core's README entry split one sentence per line, so unrelated PRs stop conflicting on them.
• Home's project cards say what each project's scan found: what it is, its languages, its branch and where it is pushed, and whether it has CI, release notes, a merge train or a PR relay.
• Home lists what is scheduled, soonest first, with each schedule's project and how often it runs, and says when Lattice is not running to run it.
• Home shows the past week's model use: each model's answers, where it runs, and the tokens its provider reported.
• Home: the app opens to every project at a glance. "Needs you" lists each session waiting on you, in any project, with what it asks or wants approved; a press opens it in its project.
• Projects shows a card for each project in its own colour, by when it last moved or with what waits on you first. Continue takes you back to the project you were last in, and a project can be brought in from a folder, a repository or the sample.
• Activity is one timeline of your sessions across projects, by day, with a filter by project. Pick one to see what was said and by which models, the tokens its providers reported, the tools it used, what it changed and ran, how its tests ended, and its log.
• Inside a project, Overview shows that project alone, with Open in Lattice, Leave the project and its map.
• A shorter rail: nine places, Ctrl+1 to Ctrl+9 in its order. Words and Data now live under Sinai, with a bar at the top of the three pages to move between them. Compute is no longer offered in the app for now.
• The Alelyon mark at the top of the rail takes you Home: out of the project you are working in, to Overview with every project at a glance.
• The app reads as one surface: panels and dashboard tiles no longer show as boxes (a tile shows a faint fill under the pointer, and its frame only while you arrange the board), tiles are as tall as what they say, edges at rest are quiet greys with gold kept for what is chosen, focused or pressed, floating cards cast one small shadow, and words are set on a short scale no smaller than 12.
• The appearance studio, in Settings > Appearance: a sample of the window drawn in your draft theme while the window keeps its own; press any part of it to pick its colour and change it with a colour wheel or a hex value, with how readable it stays shown as you go; Apply or Discard. Primary buttons now take the theme's accent.
• Themes, as in VS Code: Settings > Appearance picks Dark Modern (the new default: neutral greys and one blue accent), Midnight, Alelyon Gold (the old look), Light or High Contrast, and any colour of the theme can be changed to your own; the change shows at once and is kept.
• The identity client reads and changes projects on the account: list, invites (accept or decline), joinable and join, leave, and for the owner save, settings (public, open to join), invite, remove and delete.
• See and free a session's context: under the composer, how full its context was at its last turn and how many earlier exchanges were left out; typing /compact (with what to keep above all) writes the chat's summary now, and its later turns start from that summary instead of the earlier turns.
• Custom agents: a helper can be sent as an agent its definition describes (Claude Code's agent files: a name, a description, the tools it may use, then its instructions), from your own agents folder, a plugin's agents/ or a trusted folder's .claude/agents or .lattice/agents. The agent lists them at the start of each turn and sends a helper as one by name; a definition shapes the helper's instructions and can narrow its tools, never widen them.
• Test only: a lattice-core background-command test waits on a clock deadline, so it no longer fails under load.
• Hand work to Lattice from any harness: alelyon-cli fleet new (MCP fleet_new_group) starts a group of its own with your agent's first message, and fleet decide (fleet_decide) records a decision on a group's record so no session asks it again (shown as your agent's; you can take it off). A group made by hand now opens as soon as it is made.
• Your fleet for your own agent: with Settings, Agents on, alelyon-cli (and its MCP server) gains fleet_groups (every group in every project, with its column, waits, tasks, steps, milestones and spend), fleet_group (a group's topics, each with the step under way), fleet_waiting (every question with its options and every approval, across groups), fleet_answer (answer a question as you would) and fleet_send (write in a group's chat). Approvals stay yours, in the app; actions are asked once per session.
• Steer Lattice's sessions from any harness: alelyon-cli fleet reply (MCP fleet_reply) guides one session (a steer while it works, else its next message), and fleet stop (fleet_stop) stops its running turn.
• Your agents read the merge train too: alelyon-cli fleet train-health, train-log and flakes (MCP fleet_train_health, fleet_train_log and fleet_flakes) say how the train is, what it did last, and which tests failed then passed on its re-run. Approving stays yours, in Alelyon's window.
• Watch your fleet: alelyon-cli fleet watch prints every group and what waits for you each time something changes, and the MCP tool fleet_watch lets your own agent wait for a change (a new question, a session done or waiting) and react, instead of polling.
• Cheaper models for helpers: a helper can answer with another model than the chat's, named by its agent definition's model or by the agent for one helper (a local model for simple work, say); a model off this computer is asked of you first, as a chat's first send to it is.
• Bookmarks in the title bar: right-click a tool on the chat's wheel, or press a tab's star in the jump menu, to keep it beside the page's tabs, a click away (up to eight).
• A task group opens on its channel: one conversation with the questions waiting for you, the decisions made, the tasks its sessions started and finished, and its merge requests, each opening that session's own chat. The channel's header says how far the task has come (sessions done, working and waiting on you, steps), a session's chat shows its steps done and what it is doing, and each group on the Chats side shows its steps.
• The IDE debugger now runs Rust, C and C++ (CodeLLDB), C# (netcoredbg) and JavaScript and TypeScript (js-debug), as well as Python. A Rust or C# program is built first (cargo build or dotnet build) when the folder has no launch configuration; a folder's .vscode/launch.json is read when it has one. The call stack folds library frames into one line.
• A debugger in the IDE: click the editor's margin (or press F9) for a breakpoint, press F5 to debug the file on show, and step with F10, F11 and Shift+F11. The Debug view shows the call stack, the variables as a tree you can open, and every breakpoint; the debug console shows the program's output and evaluates expressions where it stopped. Python today, through debugpy.
• Lattice's Delivery hands work to the Chat and IDE: a merge request's Open its changes (its branch against main), and each failed job's Open its log and Ask the agent to fix (the check, its branch, its log's path and last 20 lines, typed into the composer, not sent).
• The app fills a wide window: every section's page, Lattice's tabs and its dashboard, and a Transcription or Compute tab in a window of its own run the window's whole width instead of stopping at 1640 px and leaving the rest dark. On a very wide window the dashboards set six tiles to a row, so they show more tiles side by side rather than wider ones.
• Lattice's chat and editor take what other pages hand them: a file anywhere on disk (a check's log, opened read-only at a marked line), a branch's changes against its base, a folder to work in, or a message for the agent, typed into the composer for you to send.
• Lattice keeps working for your agents with Alelyon closed: when the app does not answer, alelyon-cli starts Lattice's host (the same program, no window) over the same folders and chats, and it works beside the window when that opens. It never asks you anything, so it never does what it would ask: it works only in folders you trust, and refuses what Lattice would ask you until you open Alelyon. Settings, Agents, When Alelyon is closed, lets those sessions also use models off this computer.
• alelyon-cli exec runs Lattice on a task in a folder and prints its answer when its turn ends (exit 0 done, 3 waiting for you, 1 refused); for your agent, lattice_exec and lattice_exec_wait.
• Lattice in two processes at once can share each conversation: one this process used is let go after two minutes idle (nothing running, waiting for you, or staged), so Lattice in the other process can take it, and taken back at its next use here, loaded afresh when the other wrote to it. A conversation the other process holds no longer shows here as empty.
• Keys for everything: every shortcut and every tool of the chat's wheel can be given the keys you want in Settings > Controls (press a key to record it; clashes are marked; Reset puts a shortcut's own keys back). Hold Alt to open the wheel and let go on a tool, or Ctrl+Space. Settings > Controls also orders and removes the title bar's bookmarks and sets which way scrolling turns the wheel.
• Language intelligence in the IDE: each language's server starts when you open one of its files, and its problems show in the editor's margin and a Problems panel; F12 goes to a definition, Shift+F12 lists where a name is used, Ctrl+Q shows its documentation, and the Structure view lists the file's classes, functions and variables. Rust, Python, TypeScript/JavaScript, C/C++, C#, SQL, JSON, HTML, CSS, YAML, Bash, TOML and Markdown.
• alelyon-cli fleet map prints Lattice's topics as a map in the terminal: each group's topics with the tasks they started drawn as trees, how each stands (running, waiting on you, idle), and the topics changing the same files. fleet map <topic> shows one topic's connections instead: how it stands in a sentence, what it came from, what it started and what shares its files. --show, --around, --no-tasks, --no-files and --json narrow or export it, and agents get the same map as the fleet_map tool.
• Lattice's chat shows where its work went: a topic whose folder is on a branch with an open merge request ends with a small card (its number, pipeline and place on the merge train), and each task group carries that badge on the Chats side. Pressing either opens the merge request in Delivery.
• Lattice in two processes at once works on the same fleet in parallel: a conversation the other holds (running, waiting for you, or used there in the last two minutes) is opened, followed live, sent to, steered, stopped, answered and decided through it, over a link on this computer only with a key made at each start, so neither overrides the other.
• Lattice in two processes at once sees one fleet: each publishes the conversations it runs and the questions and approvals they wait on, and the chats list, a group's topics and what waits for you show the other's too.
• Lattice keeps its shared records whole when it runs in two processes at once (the app, and a host beside it): groups, records and decisions, summaries, tasks, schedules, projects, notes and the record of automatic decisions are each changed under a lock both processes take, read again just before writing; a due schedule runs in one process only; and a schedule is no longer cancelled when its conversation is busy in the other.
• The chat's tools live in one wheel in its top-right corner: the corner is the wheel's centre, so its lower-left quarter shows and scrolling turns it through every tool, layer by layer (Q and E jump a layer). The chat's header keeps its title and stages; the composer keeps a quiet line naming the folder, mode and model.
• A Topic map in Lattice: every topic on one graph, active and dormant, each in its group's area and tied to the topics it started and to those changing the same files. Active topics glow in their state's colour (a working one pulses), dormant ones are dimmed, and pointing at a topic lights it and its ties alike whichever it is. Scroll to zoom, drag to move the map or a topic, click a topic for its details beside the map, double-click to open its chat, walk it with the arrow keys, find with /, and Inspect one topic's connections in the Terminal's supply-chain layout. The Map button above the topics opens it on the open topic.
• Lattice's Merge train page says how the repository's merge train is: running, landing a batch, stalled or stopped, its last heartbeat and logon task, and main as the train last checked it. Its last day in four figures (pull requests landed with a bar a day, the middle time in line, pull requests sent back to their sessions, flaky re-runs), what waits in line with each session's word and Approve, the tests that flaked on the train's re-run, and the train's log newest first, narrowed to what landed, what was sent back, your word, main or the flaky. It updates itself when the train acts. Its tile on the dashboard shows the same figures.
• Lattice's core can now keep a project's versions. Each change that lands on the release branch gets a note. A version is made once a day, after the day ends, numbered by that day's largest change. It is written to CHANGELOG.md and tagged on this computer, and never pushed. Nothing in the app uses it yet; the view and the daily step come with the Atlas layout.
• The chat's tool wheel draws properly: each tool's segment fills and lights whole (it lit only half, and a triangle showed in the middle). Each layer (Chat, Views, Context, Agent, Thread) has its own colour on its band and along its tools' inner edge, a gap where one layer meets the next, and its name where it is on show; the hovered tool's name sits on a solid plate.
• When Lattice in another process (the headless host beside the app, or another window) has a chat at work, the chat says which process holds it and what it waits on there, a question or an approval with its words, or that a turn runs there, instead of only "answered in another window". The chat's status line shows how many other Lattice processes run, with each one's work on hover, and both update as those processes change.
• Lattice's agents work together in one folder, like collaborators in one document: several conversations (and the headless host beside the app) change one checkout at once, each in its own files and colour. An edit to a file another agent is in is refused, and the agent leaves a note pinned to those lines instead; the agent in the file is told at its next step, answers it (done, declined, or a question back), and the answer reaches the author. Programs other than Lattice are still kept out of a checkout Lattice writes.
• The Topic map stays readable zoomed out and in crowds: each topic's words are set the most telling first (under the pointer, picked, lit, active, then the larger), a topic whose words would cover another's goes without them until you zoom in or point at it, a tie's file count gives way to the words, and the card beside the topic under the pointer sits clear of its words.
• Marketing: post as an organization you own or administer; link a product to its Pages product (posts as updates, or a launch of a version); schedule a Pages piece for its day and time (Pages posts it even with your PC off; Update the schedule, Unschedule, and why it could not be posted); a posted piece shows its reactions, replies, reposts and the visits its counted short links brought per network. Pages' Share menu uses counted short links too.
• Post to Pages and share anywhere: Marketing's Post to Pages posts a Pages piece on your page after you confirm, and keeps its post (Copy link); Share to opens X, LinkedIn, Facebook, Reddit, Bluesky, Threads, Mastodon or Hacker News in your own browser, filled in with your words and link, for you to post there (no accounts or keys to connect). Every Pages post's Share button offers the same networks beside Copy link.
• Marketing: a new section to plan and write what you tell people about what you build. List your products (what each does, for whom, its link), plan posts, emails and scripts by day and channel with each channel's length counted (Pages 500, X 280, LinkedIn 3,000), see what is late or due this week, tick off a launch list, and ask Lattice's chat for drafts (typed into its composer for you to send). Kept on this PC; nothing is posted from the page.
• The merge train in Lattice: under the groups, Merge train shows the repository's pull requests waiting to land, in landing order, with what the train last did to each and each session's word (Auto: it merges on its own once ready; Wait: your word first), switched with one click; your own agent reads it with fleet_queue and sets a word with fleet_merge_word. Alelyon never starts the train.
• Lattice tells you when a session needs you while you are in another window: when one asks you something or finishes, the taskbar button flashes, and with Settings, Agents, When a session needs you, Also notify me, Windows shows a notification too (the first one adds an Alelyon (notifications) entry to the Start menu, which is how Windows knows whose it is). Off turns it off.
• Overview shows your projects above the dashboards: a card for each with its folder, its topics and groups, what is running and what waits on you, and when it last moved, the one you work in first and edged in gold. Enter opens Lattice working in that project (its newest topic, in its folder), Map shows only its topics on the Topic map, Leave works in none, and New project makes one. The Topic map's bar picks a project too, and opened while you work in one, it shows that project's topics; alelyon-cli fleet map takes --project.
• Your phone hears Lattice too: Settings, Agents, On my phone too sends a short notice (a session asks you something, or finishes) to the phones you turned notifications on for on your account page at alelyon.com, while you are away from Alelyon and signed in. A notice carries the session's name, never what was said. Off until you turn it on.
• Projects: the project you are in is remembered by Lattice itself, shared by the app, the host beside it and the command line; Overview offers Continue into the project you were last in. With no projects yet, Overview brings one in: open a folder, clone a repository (https, ssh or git@ addresses), or try a small sample. A project is scanned when it comes in unless you untick it: its description, license, languages, stack, build and test commands, git remote and branch (never a password or token), CI, release notes and repository tools, on this computer only and with no model; chats in the project start with the build and test commands it found.
• Review and fork a session: /review now reads the changes staged in the chat first (they wait in the Changes panel and git cannot see them), with the new staged_diff tool; and Fork under any of your messages makes a new chat holding the conversation up to that message and its answer, in the same folder and group, so you can try another way and keep the original.
• A session's card in a group shows its evidence: the files it changed, the commands and tests it ran with how each ended, the receipts they printed, and the work it saved, each opening in that session's chat.
• A session's card shows what it spent (tokens, time worked, and how its answers are priced: on this PC, on your subscription, or at a price not known here), as a group's card does; and /init writes the folder's AGENTS.md from what it holds (how to build, test and work there), staged for you to keep, as Claude Code's and Codex's /init do.
• Export a chat, encrypted: its messages, the steps each answer took and its changes with their diffs, in one file that opens in any browser with your passphrase. A passphrase is generated for you (100 bits), or type one of at least 12 characters.
• Find a past session by what was said in it: in the chats' search, Enter searches the sessions' words (not only titles) and lists the best match of each, a click picking it up where it stopped; your own agent finds them with alelyon-cli fleet search (MCP fleet_search).
• A group is one chat, its sessions status views: under an open group each session's row says what it does now (working on a step, waiting for you, idle, done) and opens a card with its steps, what it did last and a small reply box (it steers a working session, or is an idle one's next message); the questions and approvals of the group's other sessions show under its chat, answered there in the session that asked (and a question in an earlier topic of the chat is now answered in that topic, not the open one); typing @ offers the group's sessions first, and choosing one sends the message to that session only.
• Each group keeps a record that every one of its sessions starts with: your notes (you edit them), where each session stands, what was decided (your answers to its questions, and decisions its agents record with record_decision), what is still open, and where the work is (artifacts, commits, pull requests). Open it with Record in the group's actions; take off a decision that no longer holds. An agent in another harness reads it with fleet_record (alelyon-cli fleet record).
• The merge train section: Approve on a pull request that waits for your word (ready, or touching a Tier 3 area) approves its head, which lands at the train's next pass; an approved one says so; and while the train lands a batch, it says for how long.
• The merge train section names what the train does in batches: merging, a check that failed then passed on its re-run, a batch rebuilt because main moved, a pull request taken again, and a pass of the train that failed and will be tried again.
• The merge train section reads the train's new exit codes: 3 is another train holding the repository's lock; any other non-zero exit is shown as the train stopping.
• The merge train section says how the train running in the background is (running, stalled or stopped, and when it was last seen), and marks a pull request that waits for your word because it touches a Tier 3 area.
• Lattice's dashboard has a GitLab-style Delivery group: merge requests with their pipelines, pipelines drawn stage by stage (gates, builds, suites; reused checks marked), the merge train and the release trains; from the repository's PR relay, or a GitHub repository through gh; read-only and live.
• Overview is the hub of every dashboard: Needs a look across all boards, a card per section with its key tiles (each opens that part; a card's head opens its board); parts never read say so instead of showing a zero (Lattice before it starts, Compute's Training before it reads).