Changelog

What changed in each release, and what it means for you. Newest first.

Every release is installable from the same link — TESSERACT-Installer.exe — which always points at the current version. If TESSERACT is already installed, you do not need it: the app offers you the update itself.

Unreleased

• Moved folders mend what pointed at them. When a project folder moves, the app now notices every skill, memory, document and trusted folder still naming the old place. Where the move is on record it points them at the new place by itself (or asks first, in max) and tells you what changed.

• A folder nobody recorded moving is asked about once. You get one question per folder, on your phone as well as in the inbox: pick where it went, type the path, or leave it. Your answer mends the rest on the next nightly pass. Custom tools and agent cards that name it are listed for you to change; the app never edits code. Leave it, and it is never asked again.

• The Atlas lists the paths that lead nowhere, and which file each is written in.

• Morning work reaches your projects again in both the private and public workshop trees.

• One clock for the whole app. Every time the app shows, every day it counts and every scheduled job follows one time zone. It is this computer’s zone unless you pick another in Settings, System, or ask the assistant from your phone. Open screens switch to the new zone straight away.

• Changing the time zone never runs a job twice. Moving the clock forward no longer makes the scheduler run every job in hours that did not pass.

• Days start on the right hour everywhere, including places whose clocks change at midnight.

• Spending has five daily budgets. The chat brain, sub-agents, images, voice and the CLI each have their own daily cap in config/budgets.yaml, set from Settings, Cost. The CLI is counted and never limited. A fresh install starts the chat brain at $3 a day.

• See who spent it. The Monitor’s Cost tab shows one row per budget. Open one to see which agent, job or role spent, how much, its share and its calls.

• Spending over weeks, months and years. Health, What it costs has a range picker, and the bars are split by budget. Ask the assistant from your phone what you spent in a given month and it answers.

• The spending record is kept forever and stays quick to read. Older months move into a monthly archive each night and nothing is deleted.

• Spending is never left unchecked. If the app cannot track spending at start, it keeps trying on its own, tells you on the Pulse feed and your phone, and holds paid models until it is back. Free models keep working.

• Only you move a budget. Budgets change from the open app or by your yes on a card, never by a mode on its own.

• Conscience opens fast. The Cache view no longer rereads the whole spending record on every click, and its plot is drawn in one pass.

• A cut off email conversation picks up after a restart, the same way a Telegram one does.

• The token count is exact. The chat’s token figure, the Conscience payload and the point a conversation is folded all use the provider’s own count, and recount the moment you switch model.

• Tasks you write get done while you are away. Write a task and press Do it now or Do it later. Later means the next scheduled run takes it up, with or without a project. A task on a project waits until that project has a daily budget, and its row says why it is waiting.

• A task stopped by a crash asks you one question. If the app stopped while a task was sending something, the task waits and asks whether it went out, should be done again, or should be checked first. Answer on the task or from your phone, and the next turn follows your answer.

• Nothing a task already did is done twice. Every turn on a task is shown what the earlier turns already did, such as a message already sent.

• Close a task like an email. Mark done, Cancel or Delete, one at a time or several at once. Delete takes it off every list and keeps its record. You can also close one by commenting on it, by asking in chat or from your phone, or by replying with the task’s id and done, cancel or delete.

• A failed task can be picked up again, keeping what was already done.

• Replies are laid out by the app, not by labels the model had to type. The line before each piece of work, the answer, the short line read aloud and the model’s own thinking are now told apart by where they come from. A model that thinks out loud no longer fills the chat with its notes: a status line keeps one short sentence and the rest folds away as thinking.

• You choose what each chat shows. Four switches in the chat header show or hide the thinking, the status lines, the spoken line and the answer, for that chat only. Thinking arrives folded and opens when you click it.

• Your chat history is grouped by day, with today and yesterday open, so a long history reads as a few days rather than one long list.

• The assistant can have its own mailbox. Connect one from Channels: pick your provider, enter the address and an app password, and a test button checks it against the real mail servers before anything is saved. Mail from you can start work with no extra confirmation; mail from anyone else is treated as untrusted until you say otherwise, and anything it would change is still checked with you first. Off until you connect one.

• A long conversation that gets wrapped up leaves a card you can read. When the assistant hands a conversation over to a fresh start, the chat shows one card: what the work was for, what happens next, and what the conversation before it cost. Open it for the full handover, read the whole earlier conversation, and step back through every earlier part in order, each with its own cost. On your phone, ask the assistant for its past handovers and you get the same costs.

• Work you hand to another agent shows every step in the chat. Each run draws one card, open while it works, with every step it took and what came back, the same whether it runs in front of you or in the background.

• An email that got no answer now gets one saying why, in the same thread, instead of silence.

• Each chat keeps the model you chose for it. Type /model in the app or on Telegram and tap a model from the list that chat can use, in the order they are tried; only that chat switches. Telegram pins a line naming the model answering and how full the conversation is. When a different model has to answer for a while, the chat says so once, with the reason.

• The assistant can ask you a question with choices. It offers one to four questions, each with options and a place to type your own answer, and waits for you with no time limit. Answer in the app, with buttons on Telegram, or in the questions pane anywhere else; a question that comes up during an email conversation reaches you on Telegram. Decline stops the turn like Stop does, and a question from work in the background is answered on its card, after which the work carries on.

• Long conversations are handed over before they run out of room. The app measures each request before it goes out. Past the soft limit you set in Settings the assistant is told the room is getting short, and at the hard limit it is asked once whether to carry on, then the conversation starts fresh from a handover. Email conversations are handed over the same way.

• The handover is kept up to date as the work goes, so a crash loses nothing. It holds what you said and what the assistant judged, not bookkeeping, and the assistant can update it itself. It is kept for a week after its last change, and for as long as the work it describes is open.

• Work handed to another agent says what done means and comes back with what it changed. The assistant goes to a sub-agent or a second opinion only as far as the work needs, and the report shows what was changed and what was assumed. If a restart interrupts a helper, the assistant is told what it was asked and where its transcript is, and it no longer pays twice for work already handed off. A specialist can carry the playbooks it needs, and a playbook revision that does worse is rolled back, with your approval where your settings ask for it.

• A task is a plan the assistant keeps. Each step records what it produced, shown on the task card, in the Tasks room and when you ask. The plan and the task a conversation is working survive a restart, and a new conversation is told which tasks are open and whose they are instead of guessing. A finished task’s closing message carries its result, and a task says what it cost and how long it took.

• A tool can show the assistant pictures and pages, and it sees them. Images and PDFs from a tool reach a model that can read them as real pictures or pages, and any other model gets a plain note instead of a refusal. Each conversation’s own model decides what it can read, for tools, Telegram, email and uploads alike. What is counted is what is actually sent, so a long review no longer pushes the chat off its model.

• Every run opens into one pane that survives a reload. Open a sub-agent, a second opinion or a coding run from its card or from the activity list and read its record, even after a reload or a restart. Type into a running sub-agent’s pane and the message reaches the agent. A coding step shows what its command printed. Chats saved before this keep their report but not their step lists.

• Chats run side by side. Each chat has its own turn, so one long job no longer holds up another, and switching away and back keeps what was streaming. A message waiting behind a turn can be edited or deleted. A chat cut off while holding a task, or waiting on an answer you gave from your phone, resumes in its own chat and nowhere else.

• A spent limit says what stopped and how to get going again. Free models keep answering after a daily cap is reached, and a paid fallback asks first. If a provider refuses because the account has no credit, the error says to fix that and send another message, and your next message tries again at once. A provider’s per-minute limit pauses the request and resumes it instead of failing the turn.

• Lists search, sort and page the same way everywhere. Tasks, Playbooks, the Inbox and the Monitor share one table with column filters, a row count and a date picker for a day or a span. Tasks has Working, Open and Finished tabs, and Delete all cancels a running task first and says so. Anything cut off can be opened to read in full, and closed entries in the Monitor are grouped by day with older days folded.

• Saved sign-ins stay out of records, and only the open app presses its controls. Run records and logs are screened for saved sign-ins before they are written. A command typed in a shell can no longer press a control in the app, because that now needs the open app’s own key.

• Smaller fixes. A forgotten memory no longer turns up in search. After looking up a tool, the assistant calls that tool instead of a lookalike. The assistant asks for a spoken line only while voice is on, and the status line and spoken line each carry an icon. An approval answered on one screen clears its buttons on the other.

• Email carries files in both directions. A mail with a file and no words, or words and a file, arrives whole, and what a sender may attach is decided by that sender’s row before anything is opened. The assistant can answer on the same thread with a file attached, and the file it checked is the file that is sent. Your own thread now shows under Channels, Email.

• Files you send arrive the same way on every surface. One store holds them whichever way they came in, and the size limit for each kind and surface is a setting in config/channels.yaml, so the app and Telegram no longer disagree. The assistant is told what the current model can read, so a photo goes in as a picture where the model can see one.

• You can hand the assistant a folder to work in. Add it in Settings, Runtime, or ask from any surface (that always asks you first). Your credentials are still refused, and the app’s own folder, its parents and drive roots cannot be added. The config folder is protected: any change inside it asks in every mode. Deleting a whole folder always asks, and Settings, About now has tabs for your documents and your folders.

• A project is open, active or closed. Active means being worked, and several can be. One active project is the focus, where commands and coding agents run. A closed project leaves every turn and the morning’s plans. The state is a control in the project panel, and Forget asks first. A project nobody has worked on for a while parks itself, and the app never closes one for you.

• Work the assistant thinks of on its own waits for your yes. With the default settings each step is its own question, answered in the app or on Telegram, and the yes is for that step, not for the project for the day. If you do not answer, the assistant reminds you once on its regular check. Pressing “look into it” now hands the row to the assistant instead of showing a toast, and an accepted idea nobody started can be asked about.

• A scheduled check reads provider news and tells you once. On its schedule the app pings every model you have set up, and reads what each provider has published. A change worth making comes as a card, and a yes writes exactly that change. The same news is never told twice, and a local model is only pinged.

• Health says what is wrong in plain words. A model whose account is out of credit says so, a parked provider says it is parked, the models whose settings no longer match what the provider offers are named, and a row can be told to go quiet until a day you pick. After you add credit, your next message is the test, so you no longer wait out an hour.

• The app survives more of what used to take it down. A client that drops while connecting no longer leaves the app deaf. One failing message no longer ends every chat’s turn. A conversation torn in the middle of a tool call is repaired instead of being refused by the provider from then on. A job you added yourself can no longer leave the scheduler silently not running, and a crash after start leaves a trace.

• Each conversation shows what it has cost, on every surface. The window bar shows on hover what each part of the conversation cost, /clear in the app works as it does on Telegram, and the cache view plots every call’s cache hit over time.

• Paths and crash output are safer. A path is judged where the system lands it, not as it was written, so a shortcut or junction cannot reach a folder the assistant was not given. A crash copy no longer prints credentials in the clear.

1.1.3

Skills become one kind that is written, fixed and retired where you can see it, stopping or clearing a conversation keeps what matters, and everything the app records about itself now has a lifetime and a place you can read it.

• The Playbooks room is readable now. Pick a playbook from the list and you see, in plain sentences, what its numbers mean, a table of how each version has done with a note on every column, and the playbook itself laid out as steps rather than as its file.

• A skill opens on the first try. The assistant was told to read skills with a tool that could not reach them, so work that matched a skill started with a few failed lookups. It now uses the right one, and you can see the read in the conversation like any other tool call.

• A change set to apply on its own that could not be applied says why, on the card and in a message, instead of sitting in your inbox looking like every other card waiting for an answer.

• A misspelled step in a skill is caught instead of quietly leaving that step without its tool.

• Your workspace documents and skills change through their own tools, which check what goes in. A shell command that writes into that folder is refused as well, as a guard rail against the accidental one.

• The assistant stops talking to itself through the shell. A command that only prints words back is not run, and after three in one reply it is told to stop and say where it is stuck.

• Skills and playbooks are the same thing now. What used to be two kinds, one checked on the way in and one not, is one file with one contract, checked the same way whichever door it came through.

• When a skill goes wrong, the assistant says so, and a fix is proposed from what actually happened. It reports which skill, which version, which step, and a second look reads the real record of that turn rather than guessing from a description of the failure.

• An earlier version of a skill can be restored. Nothing about a skill is ever deleted, so a rewrite that turns out worse can be undone and the version before it made live again.

• Retiring a skill is always your call, from the desk or from your phone. The assistant can ask whether one should stop being used. It can never decide that for itself, in any mode.

• The observer can now suggest writing a skill, the same way it already suggests saving a memory. It only ever suggests: writing one is still the assistant’s own decision, on your approval.

• Left to work on its own, a newly written skill goes active by itself instead of waiting in your inbox, the same way every other unattended change already does. Active means active from that moment, listed among the skills the assistant carries with no extra step, and the same is true the other way round: retiring a skill takes it off that list at once.

• Approving a card that proposes a new rule for how the assistant works now actually saves it. It used to flip to approved and change nothing; now approving it does what the card said it would.

• Clearing a conversation now asks you what to keep. Three answers, wherever you type /clear: hand the state over so the next conversation knows what the work was and what is left, clear but keep what the conversation taught, or clear with nothing kept at all. The last one costs nothing; before, every way out of that question paid for the app to think about it. On your phone the three arrive as buttons, and typing still works the way it always did.

• What the app tells you a turn costs is right again. Since tools started travelling in groups, the panel had been reading the tool half about five times higher than it is: the group headings carry every tool’s full description in the message and the provider only charges for the heading. The panel counts that properly now, and says both what the tool list weighs and what it costs, so you can see what the grouping is saving. The point at which a conversation gets wrapped up was measured the same wrong way and is corrected with it.

• When a conversation is wrapped up, it hands over what it was doing right away. Before, the app read the whole conversation back afterwards to work out where things stood, which took most of a minute on a long one, and the work could not move until it finished. The assistant writes that down itself now, at the moment it decides, so the handover arrives in seconds and says the same things: what the work was for, what got done, what is left and what to do next.

• A conversation that says there is nothing left to do is believed. It ends there rather than starting fresh and carrying on with nothing, and you are told which of the two happened.

• If the room fills before any of that is written, the app asks for it, in the conversation, and tells you the limit was reached. It asks twice. If nothing comes back it says so plainly and clears the conversation with nothing carried over, rather than quietly starting a fresh one that knows nothing about what you were doing.

• What the assistant learns from a conversation no longer holds up the conversation. That pass runs on its own now, and when it fails you lose what it would have learned, never the work. A single stuck call used to leave a conversation unable to be wrapped up at all for as long as the app was running.

• Everything the app keeps about itself has a stated lifetime. And you can change it. Some of its own records had no rule at all. They grew with nothing watching, and the Thrown away panel could not tell a deliberate decision from something nobody had got round to. Every one of them now says which it is, in plain words: most are cleared on a schedule you can change from the panel, the cockpit or your phone, and the rest say why they are kept for good. Nothing that was protecting you got shorter. Your conversations, the record of every permission decision, and the file that stops a document being taken into your library twice are all kept exactly as they were.

• The record of what you have spent no longer grows without limit. It was the largest thing the app had never made a decision about, along with the copies a price recalculation leaves behind. It is kept for a year now, and those copies are cleared once they are older than that. The window can never be set shorter than the spend panel reads, so the comparison it draws between this month and the month before can never be left measuring against figures that have been cleared.

• A record the app writes down is never quietly forgotten again. Adding one without saying how long it is kept now stops the app at startup and names it, rather than leaving it to be noticed months later on a panel.

• The app stops saying it gave up on something it is fixing. When two repairs share one problem and each can only do half of it, the one that did its half was recorded as having failed. Three of those and the panel said it had stopped trying, about something it was putting right every time. It now has a way to say it did what it could, and only says it gave up when it genuinely cannot help.

• Two things going wrong at once are now two things. Every check the app makes about itself, disk space, the local models, the voice files, shared one identity when it reported a problem. So two of them failing in the same sweep counted as one: saying you had seen one quietly silenced the other, and only one of them was ever mentioned again after the first time.

• The app clears space for itself when a disk is nearly full. It brings forward the tidy up it already had scheduled for that night. It deletes only what your own settings had already marked for deletion, and changes none of those settings. If that is not enough to free the disk, it says so rather than reporting that it fixed anything.

• A conversation that ended badly opens where it is reported. The list of things the app could not finish named it and then sent you to another panel to find it. It opens in place now, with everything it did before it stopped.

• A narrow panel stops cutting names in half. When a panel is dragged narrow, the time a row was last read used to take space from the row’s own name until the name was unreadable. The time moves to its own line instead, and nothing is shortened.

• Forgetting a memory can only remove a memory. The name you give it is now treated as a name and never as a location, and the file that comes back is checked to be inside your memory store before anything reads or deletes it. Deleting a memory runs without asking you, so this is the check that stood between that convenience and a badly formed name reaching a file somewhere else. The folders you make yourself inside the store keep working.

• Where a piece of text came from is the app’s account of it, not the text’s. Anything fetched or read is fenced before the model sees it, with a label saying which tool brought it. A page written to look exactly like one of those fences used to keep its own label. It is fenced again now, so the record you would read after something went wrong names the tool that really ran.

• A conversation is remembered the same wherever you had it. The record of a chat at the desk and the same conversation on your phone were filed at different strengths, and the phone’s lost to the desk’s when the app went looking for something you had said. They are the same record now, and the ones already saved correct themselves as they are added to.

• The Day room can be asked for from anywhere. It is on the rail and the app could open it, but asking for it by name from a channel found nothing.

• The map tells you which records it means. Where it said how many records disagree, or how many links point at something that is not there, it now names them and lets you ask about one. A broken link is asked about from the record that still names it, because the missing end is the half nothing can look up. Records that nothing points at can be shown on the map itself.

• You can search your memory from the panel that describes it. The room said how much was in there and gave you no way to look inside it.

• A half finished call can be answered where you find it. When the app restarts and cannot tell whether something it started actually happened, it asks you. That question was only findable in the inbox, and now opens from the row that reports it, with the same thread and the same answer.

• Rows that cannot be opened say why, and where to look instead. A record of a conversation that ended badly is not lost; it is in the Conscience panel, under Day, and the row now says so rather than implying nothing more is known.

• The Autonomy panel can act, not just report. Every room told you what was wrong and left you nothing to press. A row that reports a fault now offers the thing that answers it, and Health is five tabs, so the faults, the decisions and the journal are separate pages instead of one wall.

• Every fault says who has it. Each row tells you whether the runtime repairs it unasked, whether it tried and stopped, or whether nobody has it yet. That is the difference between waiting and it being your turn.

• Leaving a fault alone no longer silences it for good. The button promised the row would come back if the fault returned. For faults that are reported continuously it never did, and the row stayed quiet for ever. Accepting one now lasts until the fault ends, so a fault that comes back is shown again.

• Two kinds of fault could not be acknowledged at all. A fault about the runtime as a whole, rather than one named part of it, was listed under a label the button could not match, so pressing it did nothing. That was true on every surface, the phone included.

• Stopping keeps what you typed. Anything you sent while the assistant was working used to be thrown away along with the turn you stopped. It waits now, and runs as soon as the stopped turn is finished, which is what a queued message was always for. Work running in the background is left alone: a stop ends what the assistant is doing for you here, not everything it has started.

• A stopped turn says it was stopped. In the app the reply dimmed and said nothing, and on a channel the “thinking” bubble stayed there for good. Both now say the turn was interrupted, what it had already done still stands, and that your next message carries the conversation on from there.

• A command you stop is actually stopped. Stopping a turn left any shell command it had started running, with nothing reading it. So did a command that ran past its time limit. Both now end the command and everything it started. A command deliberately left running in the background is untouched.

• A message sent while the assistant is working reaches it. On a channel you are told it will be read at the next step. If the assistant was already past its last step, it never was, and the message vanished. It is answered now either way.

• A stop reports one turn as one turn. From a phone it said it had stopped two, every time, because one turn is carried by two pieces of work inside.

• A message typed the moment the app opens is no longer lost. The window opens before the conversation list has loaded, and for those seconds there was nowhere for a message to go. It was accepted, the box cleared, and nothing was sent. The box now waits until there is somewhere to put it, and anything that does not send stays where you typed it.

1.1.2

The assistant gets accounts of its own, a long conversation stops falling over, and the panel that shows you what it is doing was rebuilt.

• The assistant can have its own sign ins. Settings, Credentials. You add an account, say who it belongs to and which addresses it may be sent to, and the assistant can use it without ever being shown the value. Each value is encrypted with your Windows sign in before it touches the disk, so the file opens on your account on this machine and nowhere else. An account can hold several boxes, because many services want an id beside a secret, and the assistant can ask you for one it does not have.
• A value that got out is caught on the way back. Every tool result in the app passes one point on its way into the conversation, and a stored value found there is replaced before it becomes part of the record. Four further places are checked: the conversation saved to disk, the request sent to the model, anything saved to memory, and the log files. The request to the model is the strict one. If your accounts cannot be read, nothing is sent.
• A sign in carried inside a web address is blanked too. A repository cloned with an access token records that token in its own address, and the assistant is told which project you have open at the start of every turn. It was going out with it. This one needs no account saved anywhere: the shape gives it away.
• A long conversation no longer goes blank. Past the size the assistant can send in one go, it used to keep the last three messages and throw the rest away silently, then be unable to recall work it had just finished. It now summarises the older part, keeps going, and tells you. What it drops first is tool output it can fetch again, never what you said.
• Long answers stop being cut off part way. The limit on a single reply was set to a fraction of what the model actually allows.
• What a conversation costs is now counted properly. Every kind of token the providers report is captured, each is priced from a rate a person checked, and summarising a conversation is billed rather than being free. Three of the six model prices had been wrong.
• A conversation on your phone survives a restart. It is saved the way one in the app is and comes back with its history. Work that finished while the app was down is handed over on your next message rather than sitting unread.
• The Autonomy panel was rebuilt. Every room opens with a sentence about what is in it, the trail at the top says where you are, and a new Atlas room draws the map of how everything is wired, including what it does not cover yet. A list of what needs you no longer quietly forgets an item.
• The memory map opens on a question rather than on the whole library. Pick where to start, narrow by kind of record or when it arrived, and connected records are drawn near each other. Labels no longer pile on top of one another.
• The assistant can write down a procedure that worked. A playbook says what problem it answers and when to use it, keeps its earlier revisions, and records how each one did. A correction you give lands on the playbook it was following.
• Cards you put away keep running. Minimising one used to take it off the page, so it stopped updating and reported itself gone.
• If the app crashes over and over and gives up restarting, it now says so.
• Notifications say what they are and why in plain words. Four kinds that nothing ever sent were removed, and what remains reaches every channel it names at once.
• The mode meant to run without you now runs without you. A handful of shell commands asked your permission whatever mode you had chosen, and away from the machine an unanswered question is not a pause, it is a refusal on a timer: the work carried on without the command and nothing said so. In that mode the one about short scripting one-liners now runs, and the other five are refused straight away with a reason instead of waiting half an hour for an answer that is not coming. The default mode is unchanged, and everything the app refuses outright is still refused in both. Every command that ran this way is in the approval record, marked as such.
• A permission prompt for a command names every rule that stopped it, not only the first, and says what your security mode does about each one.

Security fixes in this release: a crafted date could reach another chat’s transcript or a log elsewhere on the machine when looking up a past day; a command line tool the app starts could inherit the application folder as its working directory, where an edit would be erased by the next update; and the workshop falling back to the top of your home folder, which sits directly above your memories, your vault and your settings.

1.1.1

The install stops being a black box, and the source is public.

• The source code is open. TESSERACT is AGPL-3.0. You can read every line of what runs on your machine, which for something with this much access to your computer seems like the least it can offer.
• The permanent download link works. Until now the link in the README pointed at a file no release actually carried. Every release from here publishes the installer under one unchanging name, so a link you bookmark or send to someone keeps working.
• You can see what the first run is doing. Setup used to go quiet for several minutes with no way to tell installing from hung. It now shows the step it is on, the file it is fetching, and how far through that file it is — live, as it happens, for every stage.
• Declining a download actually declines it. The setup list let you switch optional components off, and some of them downloaded anyway. Turning something off now costs zero bytes, on that run and on every later launch. Graphics-card acceleration was the worst of these — unticking it installed well over a gigabyte regardless.
• Setup asks for your API keys. All of them, in the same flow that asks for the name — each one optional, each with the address to get it from, and all of them changeable later under Settings → API keys. A missing key used to surface as an error in the middle of an answer.
• Speech recognition uses your graphics card when you have one. The right libraries were missing, so it silently ran on the processor instead and every spoken turn took the better part of a minute. Transcription is now fast enough to feel immediate, and the voice it speaks with is quicker to start.
• Replies stop vanishing. A turn could end having said nothing at all — no answer, no error, nothing to retry. Several separate causes; all of them fixed, and anything that still fails now says so.
• It tells the truth about what is installed. A failed check used to read as “nothing is there”, so the app reported models as missing when they were present, and offered to download them again.
• Every launch checks itself. What this machine has is compared against what this version needs. Anything you already agreed to is repaired without asking; anything else is offered, not assumed. If nothing has changed it says nothing at all.
• The setup window is readable. It was a third too short for its own form, which clipped both edges. It is now resizable, with sensible sizes per step.
• Opening it twice tells you so, rather than showing a window with nothing behind it.

1.1.0

You name it now.

• The assistant arrives unnamed, and first run asks. It asks what to call it and what to call you, then keeps that name everywhere — the header, how it talks about itself, and the wake phrase built from it. Change any of it later in the Identity tab, which also holds the voice and the documents that describe it.
• First run asks before it downloads.
• Say its name to talk to it. Optional wake phrase, off until you turn it on.
• Spoken replies are written to be heard, composed separately from what goes on screen, so answers stop being read-aloud walls of formatting.
• Two local voices. Kokoro leads on naturalness with Piper behind it, which is several times faster than realtime on a processor — so a slow machine still speaks. Both run on your machine.
• Point any role at a local model. Name an Ollama model for a role and it gets installed for you.
• It knows where your work lives. Projects give it somewhere to keep work rather than one undifferentiated pile.

1.0.9

• Formulas render properly in chat instead of as raw LaTeX.
• New bottom bar: stage controls and view tabs in two compact menus, with the mic, model and observer one click away. It adapts to small windows instead of overlapping itself, and tucks away entirely if you want it gone.

1.0.8

• The observer is back — a hung provider call could freeze it silently forever, and a settings reload could quietly disconnect it.
• Voice transcription works on machines with no NVIDIA setup, falling back to the processor automatically instead of failing.
• External MCP tools work on fresh installs again.

1.0.7

• Quits and updates are recognised as planned rather than as crashes.
• Settings sections that fail to load retry until they succeed.
• Every failure leaves a trace: the app captures its own output, and interface errors are written to disk.

1.0.6

• Quitting and updating are fast and clean — no more thirty-second hangs.
• Settings recover automatically after a backend restart.
• Downloaded voice models stopped appearing as alarming “local changes”.
• TESSERACT ships with a working voice out of the box.

1.0.5

TESSERACT updates itself from here. When a new version is published the app shows a chip; one click downloads the installer, verifies it, and restarts into the new version. This was the last installer anyone had to run by hand.

1.0.4

First-run fixes: docked rails keep their inset, failed turns recover on their own instead of leaving a permanent error, Settings gained an About block that works even while the backend is down, and a detached Ollama no longer locks the app folder against its own update.

1.0.3

Fixed a first-run crash caused by a missing terminal dependency, and made the next failure diagnosable: a missing terminal backend now degrades the terminal panel instead of killing everything, and console output is captured to logs.

1.0.2

Repaired installs from 1.0.0 and 1.0.1, which could not start at all.

Two directories never reached the release, dropped silently while publishing — the identity scaffold, and a backend package. The published copy carried an ignore list written for a repository where those files were already tracked; in a fresh one the same rules delete real content. Fourteen files went that way.

Separately, a leftover shutdown request could make the app permanently unstartable: written for a backend that had already died, it was never consumed, so every later launch obeyed a stop order it had not asked for.

Both fixed, and the publishing step now fails rather than quietly shipping without something.