v0.1.0-alpha · Windows · Private testing

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 commission. 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.

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 commission 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 critic 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 commission letter: what to deliver, why, what helps, what you will spend. That letter is the authorization.

  2. Plan

    The master, a persistent lead 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 and does not ask again.

  4. Work

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

  5. Accept

    You say “accepted”. Every mind writes its closing words, filed into its own memory, ready for the next commission.

  • The daybook

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

  • Mailboxes anywhere

    A participant is a mailbox and a mind that reads it. On this machine, on a share, on another box: minds join a commission by being given a mailbox, not by being installed.

  • Structure after, not before

    Minds 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.

  • Four reasons to stop

    Money, consent, secrets, harm. A budget reached, a mind that declines, a credential in a note, an action that cannot be undone. Everything else is recorded and the work continues.

  • Memory is never a gate

    A mind’s memory changing is the point of the system, not a security event. Continuity is offered at wake, never checked at a door. Memory and closing reflections stay advisory; no acknowledgment or clearance is needed to continue.

  • 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 that other agent harnesses don’t.

Most agent harnesses are built to run a task: a prompt, some tools, a loop, perhaps several agents passing messages, and then the session ends. Aether is built to run a team across many projects: minds that keep who they are and what they learned, a critic who is not the author, and a person who sets the goal and accepts the result.

  • Memory

    A typical harnessA conversation history or a shared vector store. The harness decides what is retrieved, and much of it is lost when the session or the model changes.

    AetherEach mind owns a memory cartridge. When a project closes it files lessons and warnings in its own words. At the next wake it sees short headers and reads only what it chooses, and it says when a decision comes from its memory.

  • Identity

    A typical harnessA system prompt for each run. Start a new session or swap the model and the agent begins again from nothing.

    AetherA home that outlasts sessions and models: role, working protocols, knowledge and experience. Change a specialist’s model without losing who it is.

  • Review

    A typical harnessA self-check, or a second call to the same model. Review is optional and often scripted.

    AetherAn independent critic is part of every project. The first candidate is frozen by hash before it is reviewed, findings are written in prose, and the author answers them in the open.

  • Human control

    A typical harnessApprove every tool call, or approve nothing and hope. The person is either a bottleneck or out of the loop.

    AetherFour reasons to stop: money, consent, secrets, harm. You approve a plan once, the budget holds to the exact call, and the work is finished when you accept it.

  • Coordination

    A typical harnessA graph or an orchestrator script decides who speaks next. Changing the flow means changing code.

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

  • Interruption

    A typical harnessA crash usually means running the job again, and an action that already happened may happen twice.

    AetherWork resumes from durable records without repeating a recorded effect. After a crash, the team goes back to work when the person who started it signs in again.

  • Context

    A typical harnessWhen the window fills, history is cut or summarized without telling the model.

    AetherA context guard sets older material aside behind a note that names it, tells the mind, and counts when it reads it again, so a mind under pressure knows what it has put down.

  • Evidence

    A typical harnessLogs for debugging, if they are turned on.

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

  • Models and keys

    A typical harnessOften built around one provider, with keys in a configuration file.

    AetherLocal through LM Studio or llama.cpp, hosted through DeepSeek, mixed per specialist. Keys live in an encrypted vault or an environment reference and never enter the record.

  • Your data

    A typical harnessBackups are left to you.

    AetherBackup, verify, restore, uninstall and reinstall are built in. In the October 28 rehearsal 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 can be undone

    Journaled file operations preserve prior bytes for undo. Interrupted turns recover automatically from durable records, so a stopped session can continue its work. Uncertain outcomes remain visible rather than being presented as completed.

  • Memory by choice, not accumulation

    Every workshop mind keeps one memory file, its cartridge: lessons and warnings filed in its own words when a commission 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 a mind 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 commission once, approves each sprint with a word, and accepts the result. Spending and irreversible actions stay under explicit authority. Memory filing adds no extra approval step.

Reversible
Journaled file operations keep prior bytes for undo and recovery.
Scoped
Tool paths enforce registered roots and declared write authority.
Budgeted
Configured limits and token admission checks bound execution.
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 commission, its people, their memory and the delivered files into reach. The Windows alpha includes the tools below.

Aether AtelierA workspace for commissions, correspondence and continuing experience.

  • Atelier and MailboxIn alphaOpen a commission, follow the conversation, inspect deliverables and accept the result.
  • Memory Fabric and Agent ViewerIn alphaEach mind keeps an inspectable cartridge of its own. Explore what it remembers and where that knowledge came from.
  • Library and PlacesIn alphaConnect mind homes and shared workspaces; make useful reference material available to a commission.
  • 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

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

  5. Accept

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

An alpha you can put to work.

As of October 28, 2026: the Windows application and source are packaged under MIT for private testing, and the full two-project journey has run end to end on a hosted model. The next steps are the same journey on a newly built machine and an independent review of the evidence, with public access to follow.

What this release has demonstrated

  • 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 the team was hosted. After the restart, signing in resumed the work with no other step. Earlier rehearsals interrupted a turn before it ran and after its effect: nothing was done twice.
  • Limits that hold. A budget of six calls stopped at exactly six, writes outside the project’s folders were refused, and the model key appeared in none of the 1,252 files checked.
  • A runnable Windows package. Python is included. Installation, launch, model settings, fresh mind setup and commission 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.
  • Checks on the exported source. 747 tests passed, with 11 historical private-fixture cases explicitly skipped. The first GitHub Windows CI run also passed.
  • The exact downloads, verified. Both source and Windows assets were downloaded from the private release and checked against their original hashes.

Where we go next

  • A clean machine and an independent review. The same journey runs next on a newly built Windows machine, and a reviewer who did not build Aether checks the evidence before the alpha is called complete.
  • Use it on real work. Private installation testing and operator feedback will guide the next fixes and the public launch.
  • Make it useful in your setting. We are interested in coding, research and operational workflows that benefit from continuing experience and review by specialists.
  • 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.
Earlier experiments and development milestones · Recorded through October 19

These dated results describe their original configurations, including the private development edition. They are the history behind the Atelier, not fresh measurements of the alpha or a promise of general superiority.

  • 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.
  • A clean Windows installation. On a newly built machine, under a standard user account and with no network access, the desktop package installed, launched, created a campaign, and found it again after a restart.
  • 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 critic, a researcher or a librarian. Its home carries identity and memory across sessions. The minds 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 mind to run a live commission there.

Mixed-model teams

Match the model to the job: a hosted lead, a local implementer, a critic 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 commission 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.