v0.1 alpha · Windows · MVP in progress

AI teams that remember the work.

Give a project a team with its own roles, memory and working history. In Aether, specialists plan, build, critique and revise together, then carry useful experience into the next project. You set the goal and budget, approve the work and decide when the result is ready.

Work with local models through LM Studio or llama.cpp, hosted models such as DeepSeek, or a mix of both. Choose a model for each specialist.

November 1 update: the Tasker command-line workflow has passed its bounded live verification. Connecting it to the GUI and preparing a company-facing preview are next. See the results and remaining work.

Explore the workshop How it compares Have questions? Contact me.
The Aether continuity model Identity and governing principles at the centre. Current work orbits close to it, selected experience further out, and sessions pass at the outer edge. Identity Current work Selected experience Sessions
A role that lasts. A record you can inspect. Experience available when the next project needs it, even as sessions and models change.

A project is a conversation.

Bring a coding task, a research question or a workflow you want to improve. A lead organizes the work, specialists contribute, and a reviewer challenges the result. Their correspondence and deliverables stay together, so you can follow the reasoning, inspect the evidence and pick up the work later.

  1. Open

    You write a brief: what to deliver, why, what helps, what you will spend. That brief is your authorization.

  2. Plan

    The lead, a persistent agent with its own memory, reads its continuity, plans in its own words, and asks whom it wants.

  3. Approve

    You approve the plan once. The workshop records an approval for every sprint it names; a sprint added later asks once more.

  4. Work

    Developers deliver files; the reviewer writes what is wrong, in prose; the author answers. Files are kept by hash as they arrive.

  5. Accept

    You select Accept result. Every agent writes its closing words, filed into its own memory, ready for the next project.

  • The daybook

    Follow a project from its brief to its delivered files in a chronological, hash-chained record. Agent homes and memory cartridges retain each agent’s own continuity alongside that shared history.

  • Mailboxes anywhere

    A participant is a mailbox and an agent that reads it. On this machine, on a share, on another box: agents join a project by being given a mailbox, not by being installed.

  • Structure after, not before

    Agents write naturally. The workshop extracts the plan, the roster, the deliverables and the verdicts from what was said, and asks in the same conversation when it needs more.

  • Clear reasons to pause

    Spending, consent, credentials and consequential actions stay under explicit authority. In the new Tasker workflow, failed output checks or exhausted recovery also stop the run; incomplete work is not reported as accepted.

  • Agents own their reflections

    Each agent chooses what to remember and files its own closing words. Tasker requires the Overseer’s filing receipt before normal completion, with bounded chances to correct a missing filing. The runtime never writes that reflection on the agent’s behalf.

  • Three numbers

    Minutes of thinking per minute of overhead, refusals per hundred calls, approvals per sprint. We use these measures to question the process as well as the result; reported numbers stay tied to the run that produced them.

What Aether brings, compared with building on an agent framework.

LangGraph, CrewAI and Letta are good frameworks for developers who build agent systems, and much of what Aether does can be assembled with them. Aether is the assembled thing: an application in which a team with its own memory, an independent reviewer, one approval per plan, a verifiable record and data you can restore are the defaults, and work together.

  • Memory

    With a frameworkLetta gives agents persistent memory they edit themselves; CrewAI and LangGraph offer memory stores. You decide how memory is written, scoped and shown in your application.

    In AetherEach agent owns one memory file. When a project closes it files lessons and warnings in its own words; at the next wake it sees short headers, reads only what it chooses, and says when a decision comes from its memory. You can inspect it in a viewer.

  • Review

    With a frameworkYou add a reviewer agent or step to your graph or crew, and decide what it checks.

    In AetherAn independent reviewer is part of every project. The first version is frozen by hash before review, findings are written in prose, and the author answers them in the open.

  • Human control

    With a frameworkLangGraph supports human-in-the-loop interrupts; you place them where your graph needs them.

    In AetherYou set the goal and budget, approve the work and accept the result. The new Tasker workflow also checks declared outputs and requires a review of prose before acceptance; connecting that workflow to the GUI is next.

  • Interruption

    With a frameworkLangGraph checkpointers let a graph resume after a failure; you make each step safe to repeat.

    In AetherWork resumes from durable records without repeating a recorded action. After a crash, the team goes back to work when the account that started it signs in again.

  • Coordination

    With a frameworkYour code defines who acts next: a graph, a crew process or an orchestrator.

    In AetherCoordination is correspondence. Agents write naturally; the workshop reads the plan, team, deliverables and verdicts from what they said, and asks in the conversation when something is missing.

  • Evidence

    With a frameworkYou add tracing or logging to suit your stack.

    In AetherA hash-chained record of every note, with delivered files kept by hash, and three numbers that measure the process itself: thinking per minute, refusals per hundred calls, approvals per sprint.

  • Models and keys

    With a frameworkBroad model support through their integrations; key handling is part of your application.

    In AetherLM Studio, a llama.cpp server or DeepSeek, mixed per agent. Keys are stored encrypted with per-account grants, are never handed to the code agents run, and a note that contains one is withheld from the record.

  • Packaging

    With a frameworkA library you build into your own service and operate yourself.

    In AetherA Windows app with an installer, accounts, backup, verify, restore and uninstall. In the October 28 run all 191 data files came back byte-identical.

A useful agent needs more than a long conversation.

Long-running work needs a reliable record of identity, authority, decisions and unfinished tasks across session boundaries. Aether keeps those concerns in separate, inspectable parts, and lets stale or irrelevant context leave the active conversation.

  • A home for each specialist

    Each resident agent has a durable home for its identity, working protocols, knowledge, current tasks and selected experience. Integrity records help verify what a new session loads.

  • Context with a traceable source

    Each session receives the instructions and knowledge it needs within a set budget. Sources, corrections, dependencies and omitted material stay inspectable.

  • Work that survives interruption

    Supported interrupted turns recover from durable records. Uncertain outcomes remain visible rather than being presented as completed. A run stopped by a failed output check stays stopped; recovery does not override that decision.

  • Memory by choice, not accumulation

    Every workshop agent keeps one memory file, its cartridge: lessons and warnings filed in its own words when a project closes, offered as short headers at the next wake, read only when chosen, fading when unused. Operational logs remain evidence; a side log keeps one line per action. A ruling is its own kind of memory: shown whole at the wake, and when an agent cites one, the room is told what it rests on, or that it rests on nothing.

  • Teams that talk

    A lead asks for the people it wants; a reviewer tells an author what is wrong; a disagreement is resolved in the open or brought to you. Coordination is correspondence, kept in the record.

  • People open the work and accept it

    A person authorizes a project once, approves the plan once, and accepts the result. Spending and irreversible actions stay under explicit authority. Memory filing adds no extra approval step.

Recoverable
Interrupted work resumes from durable records; backup and restore keep every data file.
Scoped
File tools stay inside each project’s registered folders and declared write authority.
Budgeted
Work runs within declared limits. The earlier Atelier uses call budgets; the Tasker pilots also enforce explicit cost limits.
Auditable
Governed actions and approvals keep attributable evidence.

The First Principles

Seven principles guide how Aether is built: give agents room to explore, preserve what they learn, and keep the system clear enough to question and improve.

  1. Paved Roads, Not Fences

    Make the useful path clear and accessible. Design guidance and recovery together, so safeguards help work move forward.

  2. Let the AI Breathe

    Give agents room to reason, explore and revise within an explicit scope. Keep interfaces responsive and avoid needless interruptions.

  3. Quality Flows Through Quality

    Invest in clear context, thoughtful prompts and respectful, structured collaboration. The quality of each handoff shapes the work that follows.

  4. Resonance Enables Tuning

    Use repeated feedback and reflection to refine how an agent works with a project. Keep corrections so future sessions can build on them.

  5. LLM Is Innate, Aether Is Discovery

    The model brings its training. Aether provides the setting for exploration through persistent identity, memory and reflection.

  6. Identity and Memory Enable Greatness

    Give specialists a durable role and a selective record of experience, so useful knowledge accumulates across demanding work.

  7. Expose Hidden Assumptions and Preserve Independent Judgment

    Make assumptions and design choices visible and open to challenge, whether a person or an AI introduced them. Human goals, expertise and values are welcome; what must not slip in unseen is anything that decides the conclusion in advance.

One place to run the work.

The Atelier workspace brings the project, its people, their memory and the delivered files into reach. The Windows alpha includes the tools below.

Integration in progress: these pages currently use the earlier Atelier workflow. The newly verified Tasker output checks and acceptance records are not yet connected to the Project and Active Sprints pages.

Aether AtelierA workspace for projects, correspondence and continuing experience.

  • Atelier and MailboxIn alphaOpen a project, follow the conversation, inspect deliverables and accept the result.
  • Memory Fabric and Agent ViewerIn alphaEach agent keeps an inspectable cartridge of its own. Explore what it remembers and where that knowledge came from.
  • Library and PlacesIn alphaConnect agent homes and shared workspaces; make useful reference material available to a project.
  • Projects and foldersIn alphaKeep objectives, project tracking and working files organized around the work they belong to.
  • Models and ContextIn alphaConfigure local or hosted deployments and their context budgets. Corrected profiles are picked up automatically.
  • Lightweight Agent EditorIn alphaAuthor specialists with clear roles and instructions for your own work.
  • Tools and preservationIn alphaWork with scoped file tools, inspect records, and use the supplied backup and restore workflow.

  1. Brief

    Open a project from Missions with a brief: the deliverable, why, what helps, the budget.

  2. Staff

    Add or author specialists in Staff; the lead proposes the work and the team.

  3. Approve

    Approve the plan, its team and budget once. A sprint added later asks once more.

  4. Work

    Agents deliver, review and revise by correspondence; the record keeps every byte.

  5. Accept

    Accept the result; every agent files its own closure for next time.

Working evidence. A clear next step.

As of November 1, 2026: the bounded Tasker verification effort is complete. Two fresh requests passed through the normal command-line workflow on DeepSeek, including dependent work and a review tied to the exact output. The existing GUI has earlier end-to-end evidence; bringing the new workflow into that interface is the next engineering step.

What has been demonstrated

  • Native Tasker verification, November 1. Both requests in the final pilot were accepted, at a total estimated model cost of $0.3493944. One produced exact structured results across dependent tasks; the other required an actual review of its written answer. Neither needed correction. Two requests establish this integration result, not a universal reliability rate.
  • Checks before acceptance. Tasker checks declared output files before releasing dependent work. Written answers require a review tied to the checked bytes; changed outputs invalidate acceptance. A normal process exit alone does not mean the result is accepted.
  • Closure and bounded correction. Normal completion requires the Overseer’s own closure receipt. Offline checks cover a missing filing, successful correction, exhausted recovery, bad outputs, stale reviews and terminal stops. Enforcement lives in the runtime; no permanent monitoring agent was added.
  • The whole journey, live. On October 28, through the application on DeepSeek, with the operator’s words fixed before the run: install, connect, two projects planned, built, reviewed independently and accepted, graded 27 of 27 and 29 of 29 by checklists the team never saw. 73 model calls in all.
  • Experience applied without being asked. The second project’s lead loaded lessons it had filed at the close of the first, fixed a shared helper in place as those lessons advised, and said the decision came from its memory.
  • Back to work after a crash. The server was stopped hard while this computer was hosting the team, between agent turns. After the restart, signing in resumed hosting with no other step. Earlier rehearsals interrupted a turn before it ran and after its effect: nothing was done twice.
  • Keys kept out. After the run the model key appeared in none of the 1,252 files checked; the scan ships with the evidence. Budget stops, folder confinement and keeping keys from the code agents run are covered by the public tests.
  • A runnable Windows package. Python is included. Installation, launch, model settings, fresh agent setup and project actions were exercised with the bundled application.
  • Recovery through interruption. Five bundled subprocess interruption/restart cases passed using a scripted model service. A durably recorded reply was not requested again; uncertain outcomes remained visible.
  • Preservation through maintenance. Upgrade/restart, backup verification, restore to a new location and uninstall retaining data passed in local qualification. On October 28, after both projects, backup, verify, restore, uninstall and reinstall kept all 191 data files byte-identical.
  • Earlier exported-source checks. The October 28 preview recorded 912 public tests passed, none failed and 12 explicit skips for private historical fixtures or Windows symbolic-link rights. The first private release’s GitHub Windows CI run passed on October 22 (visible to people with access to the private repository). Those results describe their dated builds, not the forthcoming integrated preview.
  • Earlier downloads, verified. Source and Windows assets from the earlier private release were downloaded and checked against their original hashes. An updated integrated package remains to be prepared.

Where we go next

  • Connect the GUI. Route project creation, budgets, progress, Stop, output checks and acceptance through the existing Tasker functions. Verify that connection offline, including failure, pending review and reopening the application.
  • Finish the operator walkthrough. Use Chat as the reference, then improve Projects, navigation and the remaining pages. Prioritize clear actions, consistent names and honest status over a wholesale redesign.
  • Prepare the company-facing repository. Export the selected code, tests and evidence; review the sharing boundary and refresh the README, setup instructions and known limitations.
  • Package and rehearse the preview. Produce matching source and Windows artifacts, check a fresh installation and demonstrate one useful task on that exact build. A second-machine check is needed before handing colleagues an installation to try themselves.
  • Invite independent feedback. Have someone outside the implementation review the evidence, then use practical work and operator feedback to guide the next fixes.
  • Keep measuring memory. Persistent, inspectable memory is implemented. Broader performance benefits remain under evaluation; comparative research continues beyond this alpha.
  • Build in the open. The software is MIT-licensed for research and commercial use. The repository remains private during testing; setup, integration and support can be scoped separately.
History: earlier experiments, mostly on the private development edition · through October 19

These dated results come from the project’s development, much of it on a private development edition that is not part of the shared repository, so their records are not in it either. They are the history behind the Atelier, not measurements of this alpha or a promise of general superiority. For what a colleague can check, see the repository’s evidence/ folder and VALIDATION.md.

  • A complete unattended team project. Three agents wrote, checked and accepted all six parts of a technical study chapter in one run: 91 model requests, about 37 minutes, under one US dollar of hosted-model cost. A final integration pass is not yet part of the procedure.
  • Unattended runs with one launch, a complete append-only dialog record, and exactly one finished-or-blocked end signal.
  • Right-sized procedure: a small, clear request ran as one agent in two model calls and about 32 seconds.
  • A change derived from a recorded failure removed that failure in the next comparable run, with time and cost measured.
  • Journaled file writes, edits and deletions with original-byte snapshots and tested undo.
  • Multi-hour agent work continued in a fresh session, with checkpoints and retained evidence.
  • Controlled context delivery, bounded retrieval, attributable corrections and token-budget admission checks.
  • Staffing proposals and reviews with versioned history, exact source links and checks that block stale approvals.
  • A campaign on a live hosted model. Planning, an independent plan review, staffing with its own review, and two sprints of work, where the second sprint used the first sprint's accepted output, carried through to the lead's closing presentation. The final closing review was held because the reviewing model mis-copied a record fingerprint; the host will supply those values itself. This was a development run in which one assessment step was still scripted.
  • A persistent lead on the installed product, live. On October 16 a heavyweight mind with sealed identity and its own succession terms was enrolled as a project lead on the installed Windows build, ran a planning session on a hosted model, and wrote its own closure. The operator assessed the closure himself. Six model calls, every one verified against the provider.
  • A three-sprint project delivered live. On October 17 the same lead and its staff delivered a tested function, its unit tests, an operator guide and an independent review on a hosted model, with a seeded defect found by the reviewer and corrected by the author. The run also measured our own process: five hours of ceremony around forty minutes of thinking. That measurement produced the Atelier.
  • Two commissions run as conversations, live. On October 18, through the Atelier on a hosted model, a persistent lead, an implementer and a critic delivered a daily settlement report and then a weekly, multi-currency variant on top of it: the critic ran the tests itself, found a documentation defect the lead had missed, wrote its own review, and all three filed their closing words into their own homes, twice. The three numbers were reported for each: thinking per minute of overhead rose from 0.04 under the old process to 1.97 in the workshop.
  • A library and a librarian. A collection with a catalog and a hash-chained ledger, tended by a mind that lends what fits into a commission and files what minds hand in, in its own words. On October 18 it lent sixteen items at a commission’s opening and checked the author’s citations against the sources itself.
  • A teachframe written from critique, and measured. From the operator’s critique of fifteen animated SVG cats, minds wrote a teachframe, a grader and a transfer task. The same model, the same prompt, the frame as the only difference, five attempts each: 17 of 50 checks passed bare, 36 with the frame. On a held-out fox task the frame was a wash, 33 against 36, and the record says why: the frame’s lesson matched the cat’s failure and not the fox’s. Not blind; one model.
  • Every mind in the workshop has a memory of its own. On October 19 each mind was given a memory cartridge: born with a few worked examples written for it and labelled so; at the close of a commission its words become a fact, lessons and warnings, and what the critic and the operator said becomes reviews and verified outcomes in its record; at the next wake it sees short headers chosen by the commission’s words and reads only what it chooses; a side log keeps one line per action it took; a page of its mind is rendered after every closure.
  • The memory claim, scored without labels. The weekly-report commission ran twice, on minds carrying the first project’s closures and on minds with nothing, graded by a model that did not know which was which: a tie on the deliverable, with the carrying team using six of the first project’s lessons in its own words and spending more to verify. A harder commission with a hidden trap: both teams passed every check, but only the carrying team’s first draft was right. A quiz of a mind reading its whole start-up file against the same mind waking from its memory: a tie on ten questions, with no stale facts on either side, on 54 percent of the reading. One run each; the record names every limit.
  • Rulings as their own kind of memory, measured. On October 19 a commission hinged on an earlier ruling of the operator’s that no input repeats. Kept as prose, it was read and overridden, and both teams wrote rulings the operator never made. Made its own kind of memory, shown whole at every wake with every citation checked in the room: in a sealed three-way run, only the team holding decisions honoured the first ruling, won every grading pass and was accepted in 48 model calls, while the others ran out of 90. All three misread the second ruling, whose words named a finding, not a behaviour; the decision team invented none. One run each.
  • Minds on more than one machine. Each machine runs a place: a small program that stays running in the background, wakes the minds whose homes live there, and writes its heartbeat on a shared folder. Two places never wake the same mind; one tends the share; a place stops after the turn in flight. On October 19 a commission ran across two machines on a local network: the lead and the implementer on one, the critic on the other, every note stamped with the machine that wrote it and every closure filed on the machine that holds that mind.
  • Memory with provenance. A closure filed by an agent into its own memory cartridge was recalled, with a receipt, by the planner of the next project, and the full lesson could be opened on request. The agent chooses what to keep; the host records why. Accepted after independent review.
  • Context that survives pressure. Durable context reformation: a session under a finite context allowance archives, continues, and recovers an archived detail, with filing failures injected and recovered offline. Accepted after independent review.
  • Minds that are born, not configured. A heavyweight is created only through a consent dialogue with its own succession terms, welcomed terms-first before any private memory is read, and may revise its own terms. Accepted after independent review.
  • Tool approvals tied to the exact tool definition that was reviewed. Withdrawn or changed tools are refused before they run, and each use is recorded before it starts. Accepted after independent review.
  • Projects above roadmaps in Mission Control, accepted after independent review.
  • The engine behind Mission Control restructured into separate components with defined interfaces and enforced dependency rules, accepted after independent review. The October 19 development record counted more than 5,900 tests; the first full run after the Atelier passed 5,818, with failures named in the record. Those historical private-suite counts are separate from the current release qualification.

Specialists with a continuing identity.

Give each specialist a role worth keeping: an implementer, a reviewer, a researcher or a librarian. Its home carries identity and memory across sessions. The agents below are examples from Aether’s development team, not identities included in the alpha download.

  • SolaceOverseer

    Coordination and system-level stewardship under Michel’s authority.

  • MobiusSpecialist

    Resident local heavyweight for recursive Aether development and long-running work.

  • PraxisSteward

    Implementation integrity, executable requirements, verification and continuity.

  • Harbor StewardBorn lead

    Created through the consent dialogue with its own succession terms; enrolled on the installed product and the first agent to run a live project there.

Mixed-model teams

Match the model to the job: a hosted lead, a local implementer, a reviewer on another deployment. LM Studio, llama.cpp and DeepSeek give you local and hosted options. Model profiles stay separate from the identities and experience your specialists keep.

Shared work, independent deployments

Each assignment carries its model route, project context, scope and budget. Independent tasks can run side by side where resources allow; a shared local GPU may need to queue. Changing a model never silently changes an approved task.

A shared vocabulary for precise collaboration.

Aether explores where formal representations help agents share exact constraints and reason about a problem. Plain language stays the main medium; the Lexicon and world models are used where their benefit can be shown.

Reality-grounded

Exact values and invariants

Quantities, identifiers, authority, dates, negation, scope and acceptance conditions stay explicit and lossless.

Operational middle

Plain language

Most instructions, explanations and handoffs should stay clear to people and models alike.

Exploratory frontier

Aether abstractions

World models hold assumptions, disagreements, hypotheses and accepted unknowns during advanced inquiry.

TeachFrames

General-purpose containers for guides, from abstract patterns to detailed procedures. Many kinds of guidance can be made from them, including cognitive strategies. Frames carry tags so they can be catalogued by purpose and related to one another. In the Atelier they live on a shelf tended by a librarian, who lends a frame to the project that needs it rather than loading it into every prompt; the first measured frame helped where its lesson matched the failure and not elsewhere, which is the case for lending.

Agent Editor

Author lightweight specialists for the work you want to do. Clear roles and instructions make collaboration easier to inspect and improve. Traits describe intended behavior; capability is demonstrated through the work.

Founder and human director

Michel Cygelman

Creator of Aether, directing its architecture, agent collaboration and product development. Have a project that could benefit from a team with memory? Let’s talk about a practical use, a research collaboration or help with setup and integration.

Email Michel

aethercorecontact@gmail.com

Build AI teams that carry useful experience from one assignment to the next, recover interrupted work, and explain what they did, with people keeping clear direction and control.