Get the latest version.

This release is the case for a program that lives on your own machine, made in the app rather than on this page. Most of it is things a rented AI structurally cannot do: no meter, no upload, no ceiling on how much you use it — and now a way to see all three.

• What you have run, and what it did not cost. Every message and every token, counted on your machine, next to what a metered service would have billed for the same work. The comparison is labelled an estimate and shows the exact rates it used — and you can change them if you think they flatter us, and watch the figure move. The one number that is not an estimate is what you actually paid, which is nothing. Incognito conversations are deliberately not counted, because they are not written down at all.
• Point it at a folder of your own. Name a folder — your Documents, a project, a shelf of PDFs — and Sevelle can answer from what is actually in it, citing the file. Nothing is read until you add the folder, nothing outside it is ever read, and none of it is uploaded. Remove the folder and the text it pulled out is deleted in the same action.
• Your graphics card, measured. Tokens a second for every model you have actually run, on your own hardware. Not a manufacturer figure and not an estimate: a model needs three real replies before Sevelle will quote a number for it.
• A proper model library. Everything you have downloaded and everything you could, with what fits your card, what it measured at, and a place to rate each one and leave yourself a note. The ratings are yours and are never sent anywhere.
• Offline, demonstrated. Turn off your Wi-Fi and ask it something. Sevelle notices there was no route out while it answered, and says so. It is careful about what that proves — it is evidence you can repeat yourself, not a cryptographic proof.
• It can look at pictures. Paste, drop or pick an image, or show it your screen, if you are running a model that can see. If you are not, it says so rather than accepting a picture and quietly ignoring it — which is what a vision model missing part of itself will otherwise do, confidently. Every screen capture asks first, every single time, and you see the picture before it is sent.
• Three things worth trying, chosen from your actual machine. On your second run Sevelle offers a few things to do next, picked from the card it detected, the model you installed and whether you have used file sharing yet — and each one is a button that does it, not a tip.
• Example folders, and a short tour. Real folders created on your computer with real files in them, so you can watch Sevelle work on something where you can check the answer yourself.
• Skills. Drop a folder with a manifest and a prompt into your extensions folder and Sevelle can use it. A skill is instructions and nothing else — it cannot read files, run anything or reach the network — and it arrives switched off, so a folder appearing on disk can never quietly change how Sevelle behaves.
• Your own tools, and MCP servers. Declare a program in a manifest and Sevelle can run it, or connect an existing MCP server. Both go through exactly the same gates as everything else: only with commands turned on, only inside a folder you shared, and only after you approve a card showing the real command line. Arguments are handed over separately and never pasted into a command, so a filename with a semicolon in it stays a filename.
• Other apps on your PC can use your AI. An optional local address that answers questions and nothing else — no conversations, no memory, no files. It listens only to this computer, needs a key you can see and regenerate, and is off until you turn it on.

• Reading answers aloud is not in this release, and we want to say why. We had a plan on file for doing it safely. Testing it, we found the plan does not work: the standard way of driving the speech engine loads a component we are not permitted to ship in a paid program, no matter how it is called. It would have shipped, sounded fine, and been wrong. It is coming once that is done properly, and the notes in our own repo have been corrected so nobody follows the old plan into it.
• Understanding speech is there, but Sevelle does not ship it. If you install whisper.cpp yourself — it is free and separately licensed — Sevelle will find it and use it. Until then the feature says plainly that it is not available, rather than offering a button that fails when you press it.
• An outside review of this release found nineteen faults after every test was passing. Two whole features could not be reached at all from a conversation. A folder you had just revoked could come back if a scan was still running. A screenshot was being kept in your chat file and re-sent on every later message. All of them are fixed, and each one now has a test that fails if it ever returns — because the lesson is not that we found them, it is that a green suite had not.

The whole pitch is that you can trust this with your files and your candour. This release is the part that has to be true rather than merely stated: what happens to a draft when the machine dies, what "private" actually means on disk, and what Sevelle would send if something went wrong.

• Nothing you typed is lost. What is in the box is saved as you write it, and comes back if Sevelle or the machine stops. So is a reply that was still arriving — that one you could not retype, because you never saw what you lost.
• Incognito. Turn it on for a conversation and nothing more is written to disk and nothing is added to memory. Anything already saved from that chat is deleted the moment you switch it on. It ends when you close Sevelle, because an incognito chat that survived a restart would have to be written down somewhere to be remembered.
• Everything Sevelle has on you, in one list. Every file, where it is, how big it is, and what it is for — measured when you open it, not described. Tick what you want gone and it goes. Your licence key and your own knowledge folder are deliberately not erasable from that screen.
• Encrypt your conversations. Optional, and off unless you choose it. Your chats become unreadable to any other account on the PC, and to the drive read on another machine. It states plainly what it does not protect: anything running as you while you are signed in. It is not a password.
• Check Sevelle. One screen that looks for the things that actually break — a model file that did not finish downloading, a graphics driver that stopped answering, a conversation that will no longer open — and offers the specific fix rather than an error code. Files it cannot read are moved aside, never deleted.
• Crash reports you can read. If something goes wrong Sevelle writes a report. Before anything is sent you see the exact message, character for character, and its size. Nothing leaves your machine unless you press send. There is no conversation text in it.
• It tells you when it is unsure. Not by hedging — a model will say "I'm not certain" because that is how it was trained, whether or not anything is wrong. This measures the engine's own token-by-token confidence and shows you where it wavered and what it nearly said instead. It is honest about the limit, too: it measures how sure the model was of its wording, not whether the answer is right.

• Every one of these is enforced where the file is written, not in the screen. That distinction is the whole of this release. "Nothing is written to disk" implemented in the interface is an intention; one forgotten call and a conversation someone was told was private is sitting in plain text. So the server refuses on its own account, and the interface merely agrees with it.

Everything in this release is about living with Sevelle day to day — finding an old conversation, keeping the ones that matter to hand, and not retyping the same thing every week. Then, testing it, we found that closing the window had never actually given your graphics card back.

• Search every conversation you have ever had. Type in the sidebar and Sevelle looks through the whole text of every chat — your messages and its replies — not just the titles. Results show the line the match was found on, so you can tell which conversation it was before opening it.
• Pin the chats you keep coming back to, and put the rest in folders you name yourself. Pinned chats sit at the top; everything else stays grouped by date as before.
• Saved prompts, with blanks you fill in. Keep the thing you ask every week — a weekly summary, a code review, a rewrite in your voice — and write {{client}} or {{deadline}} anywhere in it. Picking the prompt asks you for those, and leaves any you skip visible in the box so nothing is silently sent half-finished.
• Named presets. Save a model, a creativity setting and a reply length together under a name like "Drafting" or "Coding", and switch between them in one click instead of setting three things by hand.
• Ask two models the same question, side by side. Useful when you are deciding whether a bigger model is worth the wait — you see both answers and how fast each one wrote. It uses the second engine, so your main model is not unloaded to do it.
• Branch a conversation from any message. Try a different direction from halfway up without losing the original. The new chat is named after the one it came from, so a sidebar full of branches still makes sense.
• Edit something you already sent, and run it again. The old answer goes, the new one takes its place, and everything after it is cleared — rather than leaving a reply to a question that is no longer on screen.
• Give one chat its own standing instructions. Separate from your project instructions, for when a single conversation needs a different voice or a rule that should not apply everywhere.
• More than one window, sharing one engine. Open a second window, or drag a conversation out into its own, and keep two things going at once. It is still one Sevelle and one loaded model — a second window does not cost you a second copy of the model.
• A command palette on Ctrl+K. New chat, settings, switch model, open a saved prompt — start typing what you want instead of looking for where it lives.

• Closing the window never gave your graphics card back. Closing Sevelle hides it to the tray, which is deliberate — but the AI model stayed loaded behind that hidden window, holding around twenty gigabytes of video memory for as long as your PC stayed on. There was no window anywhere to tell you. If you ever closed Sevelle and then found a game or another AI tool would not start, this was almost certainly why, and it would have looked like the other program's fault. Closing now frees the card within a few seconds, and reopening reloads the model. If you would rather keep it loaded so reopening is instant, right-click Sevelle by the clock and tick Keep the model loaded after closing the window. Quitting from that menu always frees it.
• Pinned chats, folders and per-chat instructions were being wiped as you typed. Everything worked until you sent your next message, at which point saving the conversation quietly dropped them. It only showed up on disk, so the app looked correct right until you reopened it.
• Search results could start mid-word and were cut to a few characters, which made them useless for telling one result from another.
• Dragging a chat into its own window opened an empty one. A malformed link meant the window never knew which conversation it was supposed to show.
• Model routing switched itself off after you closed and reopened the window, while its setting still read on. Introduced by the graphics-card fix above and caught the same evening.

• We had told you the opposite, on this website. Our own FAQ said Sevelle "uses your graphics card while it is thinking, then releases it" and "closes like a normal app". Neither was true. Nobody wrote that to mislead — it described what we all assumed it did, and no test could fail on it, because the claim lived on a web page and the behaviour lived in the app. That answer has been rewritten to say what actually happens, and we have added a test suite whose job is to check the promises on this site against the code, so a sentence like that one fails a build instead of sitting there for months.

We pointed 0.2.6 at a real 10,000-line open-source library instead of our own test folders, and found eleven things wrong with it. This is all of them.

• "Work on it until it passes" could not start at all for most real projects. Sevelle was only showing the model the first 80 characters of your check command — enough for pytest, not enough for a real one with a folder path and a couple of options. The button never appeared. If you set a check command in 0.2.6 and nothing happened, this was why.
• Reading one large file could push your own question out of Sevelle's head. A single file was allowed to be eighteen times the size of everything else in the conversation put together. Opening a 3,000-line file meant the earliest messages — including what you actually asked for — were dropped to make room. Files now come back a page at a time, and Sevelle tells you which lines it is looking at.
• Sevelle was using about half the memory your graphics card was already paying for. Two settings that were meant to match had drifted apart. Conversations can now be around 70% longer, and the length is worked out from your actual engine rather than guessed.
• Adding a function could delete the one below it. Sevelle could replace lines but had no way to say "insert here", so it improvised — and in the worst case we saw, that turned a 529-line file into 9 lines. It can now insert properly. (The restore point put every file back, which is exactly what it is for.)
• A single round could delete a lot with nobody watching. Inside an approved run, changes apply themselves so you are not asked every time. A round that removes a large chunk and puts almost nothing back now stops and waits for you instead.
• Sevelle could edit your tests to make your tests pass. That is the one thing an automatic run must never do — it can always "succeed" by breaking the check. Asking it not to was not enough, so now it cannot: any round touching your test files stops and hands the decision back.
• Sevelle had to retype your check command, and sometimes got it wrong — once inventing a folder that did not exist and then trying to build a virtual environment to fix it. It now refers to the command instead of retyping it, so it cannot be mistyped.
• Repeated steps looked like it was stuck. Three reads of the same file are three different pages; the step list now says which lines, so you can tell progress from spinning.
• Plus: a stopped run no longer says you stopped it, a file's length is now reported correctly for very large files, and a very long single line is no longer quietly cut and described as complete.

• We measured the fixing, and we are not going to oversell it. We planted single-token bugs at random in a real library and ran the loop against them. It fixed none of four. It reliably runs your check, reads what failed, shows you every change and puts it all back — but working out what is actually wrong with your code is beyond a local model today. The button now says "Try to fix it, up to 3 rounds", because that is what it does.

Sevelle can now hold a whole project in mind — the folder, how you want it worked on, and what still needs doing — instead of starting from nothing every conversation.

• Projects. Give a folder a name, a short description, and standing instructions — house style, what never to touch, how you like things named. Sevelle reads them at the start of every conversation about that folder, so you stop repeating yourself.
• Your files, in the sidebar. A live tree of the folder you shared. Click a file to talk about it.
• Changes across several files, as one decision. A rename that touches six files is now one card with every file's changes shown, and one approve button. It either all happens or none of it does — including if the power goes out halfway, which is the case that used to leave a folder half-changed.
• Run a check and read the result back. Tell Sevelle the command that says whether your work is right — a test command, a build, a linter — and it can run it (with your approval, every time) and read the output.
• "Try to fix it, up to 3 rounds." When a check fails, that button appears. Sevelle edits, re-runs your check, reads what failed and tries again, for as many rounds as you allow. You watch each round and can stop at any point, and the folder is copied first so one click puts everything back. Be realistic about what it can do: we planted single-token bugs at random in a real 10,000-line library and it fixed none of four. It is an attempt you supervise, not an errand you hand over — and the honest reason we ship it anyway is that everything around it (running your check, reading the failure, showing you every change, putting it all back) is useful even when the fix is wrong.
• A plan it keeps up to date. A plain checklist of what's done, what's next, and what's blocked, living in the folder as an ordinary file you can read and edit yourself.
• It can read the shape of a codebase — the layout, the entry points, what's a test — and see your uncommitted git changes, so its suggestions are about the code you have rather than the code it guessed at.
• Templates. Starting points for a codebase, a piece of writing, research, or a folder of records — each with instructions that suit that kind of work. A writing project doesn't get offered git tools.

• Edits are more reliable. Sevelle can now say "replace lines 40 to 52" instead of having to reproduce the existing text exactly to find it. Retyping was where edits most often failed, and this removes the need for it.
• Nothing runs on your machine unseen. Every command is shown in full, and waits for you — including inside a "work on it until it passes" loop, which is where it matters most.

• Settings could be emptied by a power cut. Sevelle now makes sure a file is genuinely on the disk before replacing the old one. This one was found the hard way, twice, and it could have taken your licence key with it.
• Imported conversations were duplicated. Importing the same export twice now updates what's there instead of adding a second copy of everything.
• Approval cards could linger after they stopped meaning anything. A card for something already handled now goes away instead of offering a button that does nothing.

• The parts of this release that decide things — picking the right files, writing a correct fix, knowing when to keep going — lean on the model you have loaded. We tested them on a large model and on a small one. On the small one they don't work well; it will still ask before doing anything, so nothing unsafe happens, but you'll get more out of this release on a larger model. Gating this properly is next on our list.

Sevelle can now show you exactly what a change will do before you agree to it — and put things back if you change your mind.

• See the actual change before you approve it. When Sevelle offers to edit a file, you now see the real lines going in and out, counted. No more agreeing to a description and finding out afterwards what it meant.
• Restore points. Before a big set of changes, Sevelle can take a copy of your folder — one click puts everything back. Offered automatically once a job is more than about ten files, which is the point where undoing them one at a time stops being realistic.
• Ctrl+Shift+Space brings Sevelle up from anywhere in Windows, with the cursor already in the box. Press it again when Sevelle is already in front and it gets out of the way.
• Right-click any file → "Ask Sevelle about this". Turn it on in Settings; it adds one entry to your right-click menu and removes it cleanly when you turn it off.
• Watched folders and recurring jobs. Have Sevelle keep an eye on a folder, or check something every morning. Neither ever changes a file on its own — they start a conversation, and anything that follows still needs your approval.
• A record of every action. Everything Sevelle has done to your files, laid out and searchable. The plain text log is still there and still the thing you can check us against.

• The approval card now describes the real file. It used to be drawn from what the model said it was about to do. It's now drawn from what will actually happen — the resolved path, checked against the folder you shared. If those differ, it says so, and anything that can't run doesn't get an approve button at all.
• Large jobs are summarised rather than listed. A two-hundred item list isn't something anyone reads before clicking, and a list nobody reads isn't consent.

• Large jobs were quietly doing part of the work. A job of more than sixty file operations ran the first sixty, then reported success. Every operation now runs, or you're told why not.
• "Restore point made" could be untrue. If the restore point couldn't be saved, Sevelle said it had been anyway — and then made changes on the strength of it. It now refuses to continue instead.
• Saving a job could silently do nothing. A watched folder would appear to save and be gone after a restart, with nothing saying why.
• Turning off "changing files" could be undone by a right-click. Fixed — only one part of Sevelle writes your settings now.
• Scheduled jobs could skip a day. A job set for 9am was missed entirely if Sevelle was busy at that exact minute, or the machine was asleep. A missed time is now caught rather than lost.

Sevelle gets a memory you can actually see and correct — and one that keeps what it learns about different parts of your life apart.

• See everything Sevelle remembers, and fix it. Settings now lists every fact it has picked up about you. Click any line to correct it, × to forget it, or clear the lot. Until now the only way to check was to open a text file, and the only way to fix something was to edit it by hand.
• What it learns in one folder stays with that folder. Share your accounts folder and what Sevelle picks up while working there won't turn up while you're writing something else. If you don't share a folder, nothing changes — it's the same single memory you already had, in the same place.
• It stops believing two contradictory things. Tell it you've moved from one version of something to another and the old note is retired rather than left to argue with the new one. Nothing is deleted: retired notes move to their own section with the date, so you can always see what changed.
• Facts and preferences are kept apart. "I live in Chicago" is something to know; "keep answers short" is an instruction. They're stored separately and used differently — your preferences now apply to every answer, not just the ones that happen to mention them.
• A timeline of your chats. A second view of your history showing when you worked on what, with a bar for each day. Useful once you have a few weeks behind you.

• Memory no longer stops growing. Sevelle used to read only the first couple of thousand characters of what it knew about you, so anything learned after that was quietly ignored. It now looks up what's relevant to the question in front of it, which means memory can keep growing for years without slowing anything down.
• The Knowledge folder reads far more than it did. Spreadsheets, web pages, RTF, JSON, logs and source files on top of the four formats it handled before — twenty in all. It also tells you plainly if something in the folder couldn't be read, instead of leaving you wondering why a search found nothing.

• Sevelle now actually remembers things you tell it. On the reasoning models most people run, the part that spots a lasting fact was being cut off before it could answer — so it silently saved nothing, ever. This is the fix worth having in this release.
• Short, vague questions are tidied up again before being sent. Same cause as above, same fix.
• The memory panel showed its own help text as though those were things Sevelle had learned about you.
• Backups now include everything. Memory kept for individual folders was being left out, so moving to a new PC would have quietly lost it.

Sevelle gets quicker at the easy questions and more careful about the hard ones — and, if your graphics card has room, learns to keep a second smaller model running to answer the simple things almost instantly.

• Quick answers from a second model. If you have spare graphics memory, Sevelle can keep a small model loaded alongside your main one and send it the easy questions — "how many minutes in a day", "convert 40C to F". On the machine this was built on that's about five times faster. Turn it on in Settings under Fast answers; it tells you exactly how much memory it needs and how much you have, and it refuses to start rather than risk your main model. Anything to do with your files, your code, or a conversation already underway always goes to the full model.
• Every reply now says how fast it was written, and which model wrote it.
• A "think longer" button. Click the brain before you send a hard question and Sevelle gives that one answer more room to work, and always uses the full model. It applies to the next message only, then switches itself off — a setting you left on three questions ago shouldn't quietly slow everything down.
• Sevelle checks its own code before showing it to you. If it writes Python, JavaScript, PowerShell or JSON that wouldn't run, it notices and fixes it before the answer appears. Nothing is ever executed to test it — the code is only parsed.

• Answers are tuned to what you asked for. Code and factual questions get steadier, more predictable replies; brainstorming and writing get more variety. Your Creativity setting still leads — this nudges it, it doesn't overrule it.
• Short, vague questions get quietly tidied up before they're sent. What you typed is what stays on screen and in your saved chat; only the copy the model sees is improved.
• Long conversations remember their beginning. Older messages are still condensed to save room, but your opening message is now kept word for word instead of being summarised down to nothing over time.
• When Sevelle asks to use one of your files, the request can no longer come out malformed. Previously a badly-formed request meant a wasted turn and a retry.

• A corrected code answer no longer leaves the broken one in your chat history. Reopening an older conversation could show a discarded first attempt along with a message that looked like it came from you but never did.
• The stop button works during a quick answer.
• The "think longer" button keeps its setting if you click it while Sevelle is still writing the previous reply.
• Backup sizes read correctly. A 4 MB backup used to be shown as "0 GB".

• Two planned speed features were cut after testing rather than shipped. One depends on an engine capability that isn't actually there — it accepts the setting and ignores it. The other, a way of double-checking short answers, turned out to make questions slower more often than it helped, so it was removed. Both are written up in full; neither is worth shipping as a number that flatters us.

A pass over the everyday edges: reading a long reply while it's still arriving, getting a chat back after you delete it, and using the whole app from the keyboard.

• You can read a reply while it's still being written. Scrolling up during a long answer used to drag you back to the bottom about nine times a second, so there was no way to re-read the start of an answer until it finished. Sevelle now follows the end of the conversation only while you're already there, and offers a Jump to latest button when you're not.
• Deleting a chat asks first, and can be undone. It used to be one click on a small × that only appears on hover, instant and permanent. Deleting a model — a file you can download again — already asked twice. Now the × arms first, and the delete itself offers Undo.
• Escape closes things. It only ever closed Settings; the model picker and the status window had no way out but a small × in the corner. Clicking the dimmed area behind them works now too.
• Switching light and dark is quick again, and Settings no longer feels heavy while a reply is arriving behind it.

• Restore from a backup. Settings could make one but never put one back, which made "handy for moving Sevelle to another PC" advice you couldn't follow. Your chats and knowledge files are added; nothing already there is deleted.
• Drop a file straight onto the chat, or paste one you copied in Explorer.
• Your chats are grouped by when you last used them — Today, Yesterday, and so on — instead of one long identical list.
• Start the engine from the status window if replies ever stop coming, instead of being shown a red dot and a port number.
• The whole app works from the keyboard. Arrow keys move through your chats, Enter opens, F2 renames, Delete removes. Ctrl+L jumps to the message box and typing anywhere lands there.

Sevelle gets more useful with files, stops pretending it can't touch them, and finally formats replies while it's writing them.

• Save any code block to a file. Hover a block of code and click Save. You choose where it goes, so this works even in a chat where you haven't shared anything — and Sevelle will point you at it instead of telling you to retype the code into Notepad.
• Share more than one folder with a chat, or share just a single file when that's all the job needs. A shared file gives Sevelle that file and nothing else in its folder. Each one can be unshared from the + menu without closing the chat.
• Reply length and creativity in Settings. Choose how much room Sevelle has to answer, and whether it sticks to the likeliest wording (better for code and facts) or takes more chances (better for writing and ideas).
• Ask Sevelle to remind you. "Remind me in two hours to send the invoice." It tells you at the time — it never runs anything on its own, and anything that needs doing you approve then, as usual. Reminders you missed while Sevelle was closed still show up, and say how late they are.
• Real speeds for every model. The picker now shows how fast each model actually runs on your PC, measured from your own chats, and recommends based on that instead of guessing from your graphics card.
• An activity log you can read. Every file action Sevelle takes — what it did, when, and whether it worked — is written to a plain text file in your Sevelle folder. Failures included. File contents never are.
• A note about what changed the first time you open Sevelle after an update.

• Looking at your files no longer asks each time. Sharing a folder is the permission — a second prompt to confirm each read told you nothing you hadn't already decided, and answering questions that don't need thought is how people learn to click Approve without reading it. So Sevelle now reads, lists and searches what you've shared straight away, and the approval is saved for what it's actually for: anything that creates, edits, moves or removes a file, and any command, still shows you exactly what it will do and waits. Every read is still written to the activity log.
• Sevelle can read PDFs and Word documents in a folder you've shared, rather than only plain text — and searching looks inside them too. A scanned document says so instead of appearing empty.
• It won't remove anything too large for the Recycle Bin, or on a network or removable drive, because Windows deletes those permanently instead of recycling them.

• Code keeps its indentation. Replies were having runs of spaces collapsed on the way to the screen, which flattened every level of indentation in a code block — Python written by Sevelle looked right and wouldn't run.
• Replies format as they're written. Until now the text arrived as one flat grey block and only snapped into headings, bold and code blocks once it finished — so the whole time Sevelle was working, it looked broken.
• Message times are the times you sent them. Reopening an old conversation used to stamp every message with the moment you clicked on it.
• A chat remembers which model wrote it and offers to switch back, so picking up an old conversation on a smaller model doesn't quietly change the quality of the answers.
• Sevelle now refuses to bin any folder you shared with it, not just the first one.

Sevelle can now help with your files — if you want it to. Everything here is switched off until you turn it on, and it asks permission before it changes anything.

• Share a folder with a chat. Use the + button beside the message box to let Sevelle look at one folder you choose. It can list, read and search what's in there — so you can ask "what's in these files?" or "find anything about the invoice". Sharing lasts for that conversation only, and Sevelle can't reach anywhere else on your computer.
• Let it organise, if you like. A second switch lets Sevelle create folders, rename, move and write files in that folder. It shows you every change first. Anything it removes goes to your Recycle Bin, never permanently deleted.
• Undo last action. Changed your mind? One button puts it back — and it still works after closing and reopening Sevelle. A set of changes you approved together undoes together.
• It tells you the plan first. For anything with several steps, Sevelle explains what it intends to do and waits for you to agree, then shows all the changes together instead of asking you the same question twenty times.
• Running commands (advanced, off by default). If you switch it on, Sevelle can propose a Windows command, shown to you in full, which runs only if you allow it. Two honest warnings: a command isn't limited to your shared folder the way file actions are, and it can't be undone. Sevelle refuses obviously destructive commands and flags ones that look like they reach outside your folder. For adults.
• A backup button for your conversations, memory and settings — one file you keep.

• Sevelle now keeps plenty of disk space free rather than letting a big model download fill your drive.
• The Windows file details for Sevelle now show its version and publisher properly.

Small everyday improvements: work with individual messages, keep your own backup, and see how much of a long conversation Sevelle can still hold.

• Message actions. Hover any message to copy it. You can edit one of your own messages and ask again, or ask Sevelle for a fresh take on a reply you didn't like.
• Back up your data. One button saves your conversations, memory and settings into a single file you keep — handy for moving Sevelle to another computer.
• Chat memory meter. A long conversation eventually outgrows what the model can hold at once. Sevelle now shows how full that is, and tells you plainly when the earliest messages stop being included.

• Model downloads show their speed and how long is left, and quietly retry themselves if your connection drops.
• Sevelle checks your installed models at startup and flags a damaged one instead of failing to load later.

You're more in control of your models and updates: manage what's on your disk, downloads that survive a dropped connection, and optional one-click updates.

• Manage your models. Remove any downloaded model to free up space, and see at a glance how much disk your models use and how much is free. Each model now shows its name and exactly what graphics card it needs.
• Sturdier downloads. A model download now resumes where it left off if your connection drops, shows its progress from anywhere in the app, and is checked for integrity so a corrupted file can't slip through.
• Optional automatic updates. Off by default. Turn it on and Sevelle will download a new version in the background, verify it's genuine, and offer a one-click install — you always approve, nothing installs on its own.

• Sevelle warns before loading a model too big for your graphics card, and won't start a download that wouldn't fit on your drive.

Sevelle now activates once when you first open it, and its AI models are served from our own servers.

• One-time activation. The first time you open Sevelle, you enter the ID from your receipt once. After that it runs on your own machine, offline, exactly as before — no account and no repeat sign-ins.
• Models come straight from us. The AI models now download from Sevelle's own servers rather than a third-party host, so setup is faster and more reliable and doesn't depend on anyone else staying online.
• A bigger library. More than 20 models are now available, sorted by how much video memory your graphics card has, so there's a right-sized choice whether you're on a laptop or a powerful GPU.

• A licence that's been refunded or cancelled is deactivated. Sevelle only checks this when it's online, and a valid copy keeps working normally — including fully offline.

A bug-fix release, and one genuine privacy fix that's worth explaining properly rather than burying in a list.

• Sevelle never loads images from the internet. Sevelle is text-only, but it would occasionally write out an image link anyway, and the chat window would try to load it. Nothing about you or your conversation was ever included in that request — but the promise is that nothing leaves your machine, so image links are now shown as plain text and never fetched.

• Undo works. When Sevelle remembered something and you clicked "undo", it often did nothing — it only worked on short, simple facts, and silently failed on anything longer or with unusual spacing. It now removes what it says it removes.
• Switching between light and dark is fast again. It used to get slower the longer your conversation was.

• Messages are easier to tell apart: the small lettered circles are gone, replaced by a name and a quiet gold line down the side of Sevelle's replies.
• Switching theme now sweeps across the window from the button, the same way it does on this site.
• Sevelle is friendly, but it's clearer now that it's an assistant rather than a person — it won't play along with being your partner. It's used by people as young as 13, and that felt like the right line.

The first version available to buy. A leaner install, and the terms are now shown and accepted during setup rather than buried on a page somewhere.

• The full licence terms are shown during installation, and setup won't continue until you accept them. Nothing about how Sevelle works should be a surprise after you've paid.

• Smaller, faster install — roughly 300 MB trimmed from the download.

• Updating works while Sevelle is still open. Previously the update failed with an error about a file being in use, and you had to quit the app first.

• PDF attachments — drop a PDF into a chat and ask about it.
• A switch in Settings to turn the startup update check off completely.

• Switching chats while a reply was still being written could drop that reply into the wrong conversation. This was the worst bug in the app and it's gone.
• Chat history is now written atomically, so a crash mid-save can't leave a conversation truncated.
• A console window no longer flashes on screen at startup.
• Settings showed the wrong folder for where your memory file lives. It now shows the real one.
• The context length the app reported didn't match what the engine was actually given.

• The placeholder letter avatars beside messages.

• Bundled dependencies updated to current versions, including a security update to the image library.
• Groundwork for licence-key delivery and in-app updates.

The first build. Detects your graphics card, recommends a model that will actually run on it, downloads it, and opens a chat window — all offline after that first download. Chats and memory stored as plain files you own.