Small steps.
More useful work.

Android phone

Same version as Windows, with models picked for your phone.

The phone app now has the Windows 0.8.8 behaviour, and its version number matches Windows.

Before you install. Direct APK, not a Google Play listing. Signed with the same key as 4.0.x, so it installs over it. Android 9+, ARM64, 6.3 MB. SHA-256 0106e395364982f9627b283201727aa5c1f0173cb3298a6aa21479d1ef1acc74. Not yet tested on a phone. The version number moved from 4.0 to 0.8.8 to match Windows, so a phone with 4.0.x needs this one manual install; later Android updates are then found by the app.

Android phone

Works with Chitta 0.8.0 on your PC.

A compatibility update for the phone link and update check.

Before you install. Direct APK, not a Google Play listing. Signed with the same key as 4.0.0, so it installs over it. Android 9+, ARM64, 6.3 MB. SHA-256 ae8cef81beafd1a0297e2456c8f4c4b7b9b9dbb452d53d3a1851401c348f106c. Not yet tested on a phone; 4.0.0 phones need this one manual install to receive later Android updates.

Main Windows release

Routing, pictures and coding now finish or decline honestly instead of failing midway

Chitta 0.9.11 makes three things finish or decline honestly instead of failing midway. Arch-Router's waiting time now has one owner, set from how long routing really takes on this PC, and a routing request that ends while another step is busy no longer blocks later turns. Pictures are planned against what really finished on this PC: the kept-warm painter is used only when it fits with its text encoder loaded, a memory stop is recorded and reported as low memory, and the same painter is not tried again at the same free memory. A stored coding-model memory peak that is far above what the model file can need is set aside and marked for recalibration; the 2 GB memory floor is unchanged. Also included, not published on their own: Chitta 0.9.10 fixes Arch-Router's short route: the routing request for the route name was being refused by the context check as too small, so routing quietly fell back to the quick check. It now passes and Arch-Router decides the route again. Everything in 0.9.9 stays: Chitta 0.9.9 checks the programs it writes by running them. When a page is built in planned steps, the finished page is now rendered in a hidden window before you see it: Chitta looks for console errors, checks that every chart actually drew and that the controls redraw them, repairs a failing part once, and otherwise labels it Unfinished. For a collection of series shown as charts, the plan is concrete: the contract lists each series by name with its formula, every series is one small function with one fixed data shape, and the page and its wiring are generated from that contract, so the parts always fit together. Code steps now only run on real code models (chosen by their catalogue role, never by file name), and Prāṇa estimates a model's memory at the context size a step actually asks for, from the model's own KV-cache size, with the 2 GB floor and a safety margin. Code models are measured at 4k and 8k context when the device is idle. Also included, not published on their own: Chitta 0.9.8 plans multi-part programs instead of declining them when the big coding model does not fit. A request such as a page that charts various mathematical series is judged by its structure: Chitta writes a short contract first (file layout, the open-source library and how it loads, shared function names and data shape), then the page skeleton, one part per feature or series and the wiring, on the best coding model that actually fits in free memory. It shows the plan and estimated time before starting, syntax-checks every part, repairs a failing part once, and labels anything still failing as Unfinished while keeping the working parts. One tightly coupled function or algorithm is still declined honestly. Chitta 0.9.7 keeps a chat's context when it moves between models. A short follow-up such as "try again" after a stopped coding turn now continues that coding work instead of being taken as a picture edit. When memory is too short for the coding model, Chitta first measures what it can load and, only if the work fits, writes it in a few small steps on a smaller model, each step carrying the request, the plan, earlier parts and the recent chat, then merges the parts into one labelled answer; step progress is kept on this PC so nothing is lost. Pictures and single pieces of code that must be written whole are not split; Chitta says so before it starts. Small models get a context fitted to their real size. Everything in 0.9.6 stays. Windows is unsigned; the Android app is 0.8.8.

Previous Windows release

A plugin slot, plugin routing that never holds up chat, and Arch-Router's trained adapter now really loads

Chitta 0.9.6 fixes plugin routing. With a plugin that has many examples, Chitta no longer re-reads all of them on every message: they are prepared once in the background while Chitta is idle, kept on this PC, and never hold up chat, pictures or web answers; until they are ready, plain word matching decides. Short examples no longer pull in unrelated questions (for example a list of films is not sent to a plugin because one of its examples is "top 5"). A key you skip is not asked for again on every message, and a plugin turn never waits on a key it does not need; you can add or change keys from the plugin's page (Keys). Questions from a plugin's own page stay in one chat for that page instead of a new chat each time. If a plugin's settings file has a problem, Chitta now tells you in a small note with the details tucked away. Quitting no longer waits for that background work, and plugin programs are stopped on quit. Arch-Router's trained adapter now really loads in the app (it was being dropped on the way to the loader), so its short route list is used. 0.9.6 was checked with the offline test suite and a quick core check in the app on the Surface PC; the full live check on Windows was not run for this release. Everything in 0.9.5 stays: Chitta 0.9.5 adds a plugin slot. A plugin is a separate program you install yourself in C:\AI\Chitta\plugins; Chitta never ships one and never writes into a plugin's folder. When a plugin is present, questions that match its examples are answered by it in the chat, and the details stay in the closed "How I answered" section. The first time you use a plugin, Chitta shows what it does and asks you once. Before a plugin runs, Prāṇa checks there is enough free memory for it; if not, it says so and the plugin does not start. Stop ends a running plugin. Keys a plugin needs are asked for with a hidden field, kept in Windows secure storage and given only to that plugin. A plugin may add its own page to the sidebar, shown only from this PC (localhost). Scheduled plugin runs use Chitta's scheduler and stop when automation is paused. Without plugins Chitta works exactly as in 0.9.4. Everything in 0.9.4 stays: Chitta 0.9.4 makes routing faster and steadier. Arch-Router now has a small Chitta-trained adapter and a short route list: it answers with the route name only, and the fixed part of its instructions is kept ready on disk, so on the Surface PC its routing answer took about a quarter of a second instead of about three quarters (median of a 20-prompt check), and a routed request was about 0.4 s quicker overall, model loading included. Prāṇa still loads Arch-Router only for that decision and unloads it straight after; if there is not enough RAM, the closed "How I answered" section says "RAM not available" and the quick neural check routes alone. In Auto, a new neural chain check keeps only clear, confident single requests with the quick check; chains of helpers, unsure requests, follow-ups and pasted or longer requests go to Arch-Router (on PCs with 8 GB or more). Deep and Thinking still send every message to Arch-Router, then Śilpī-Laghu, then the quick check with an honest note. Requests to study, compare or look at something in depth are no longer mistaken for coding, so a correct "research the web, then write, then paint" chain is kept, and asking to edit a picture when none is attached makes a new picture instead of being dropped. Rakṣā now locks original face pixels only when you ask (for example "keep my face exactly the same"), and then finds the faces itself; it asks you to mark a face only when it cannot find one or is unsure. A Settings switch can make it lock faces on every photo edit (off by default). Pictures that use your photo as a reference now pick the strongest picture model that can really take a reference, and say so when Citra-Tīkṣṇa · Uttama cannot (it cannot use a reference photo in this build), instead of quietly falling to the smallest model. On a new PC, first-run setup now also selects Buddhi · Mārga (the router and its adapter), Cakṣu (picture understanding), Smṛti and Nyāya by default, with their sizes shown and nothing downloaded until you agree; an existing install is told once which of them are missing and can download them from Settings → Models. The 🎮 games orb is now always at the bottom-right, above the message box; it never opens by itself. Everything in 0.9.1 stays. Windows is unsigned; the Android app is 0.8.8.

Previous Windows release

Faster routing with a Chitta-trained Arch-Router adapter, faces locked only when you ask, and every helper offered on a new PC

Chitta 0.9.4 makes routing faster and steadier. Arch-Router now has a small Chitta-trained adapter and a short route list: it answers with the route name only, and the fixed part of its instructions is kept ready on disk, so on the Surface PC its routing answer took about a quarter of a second instead of about three quarters (median of a 20-prompt check), and a routed request was about 0.4 s quicker overall, model loading included. Prāṇa still loads Arch-Router only for that decision and unloads it straight after; if there is not enough RAM, the closed "How I answered" section says "RAM not available" and the quick neural check routes alone. In Auto, a new neural chain check keeps only clear, confident single requests with the quick check; chains of helpers, unsure requests, follow-ups and pasted or longer requests go to Arch-Router (on PCs with 8 GB or more). Deep and Thinking still send every message to Arch-Router, then Śilpī-Laghu, then the quick check with an honest note. Requests to study, compare or look at something in depth are no longer mistaken for coding, so a correct "research the web, then write, then paint" chain is kept, and asking to edit a picture when none is attached makes a new picture instead of being dropped. Rakṣā now locks original face pixels only when you ask (for example "keep my face exactly the same"), and then finds the faces itself; it asks you to mark a face only when it cannot find one or is unsure. A Settings switch can make it lock faces on every photo edit (off by default). Pictures that use your photo as a reference now pick the strongest picture model that can really take a reference, and say so when Citra-Tīkṣṇa · Uttama cannot (it cannot use a reference photo in this build), instead of quietly falling to the smallest model. On a new PC, first-run setup now also selects Buddhi · Mārga (the router and its adapter), Cakṣu (picture understanding), Smṛti and Nyāya by default, with their sizes shown and nothing downloaded until you agree; an existing install is told once which of them are missing and can download them from Settings → Models. The 🎮 games orb is now always at the bottom-right, above the message box; it never opens by itself. Everything in 0.9.1 stays. Windows is unsigned; the Android app is 0.8.8. 0.9.4 was checked with the offline test suite and a quick routing check on the Surface PC; the full live check on Windows was not run for this release.

Previous Windows release

One routing pipeline: a quick neural check for clear asks, Arch-Router for the rest, every chain checked in code

Chitta 0.9.3 routes each request through one pipeline. A quick neural check answers clear, short, single requests; anything longer, pasted, with several asks, a follow-up or mixed languages goes to Arch-Router 1.5B, which chooses the helper or the chain of helpers by meaning from a plain-word list built from Chitta's own capabilities (for example web research, then writing, then pictures). Prāṇa loads Arch-Router for that decision and unloads it straight after; in Deep and Thinking it routes every message, with Śilpī-Laghu as the fallback router, and if neither fits in memory the closed "How I answered" section says "RAM not available" and the quick check routes alone. Every chain is checked in code: each thing you asked for needs a step, a request that needs real-world facts starts with web research, a model you name (such as Citra Uttama) gets its own step, and editing or reading a picture needs an attached picture. Vāk, the quick 2.6B model, never routes, plans, paints, codes, researches or works the PC, and a saved Vāk file applies only to spoken and quick replies. Each answer has two buttons: Regenerate keeps the same route, model and picture tier and makes a new version; Re-route works out why the route did not fit (wrong helper, missing step, pasted text misread, or a model stepped down for memory) and picks a different route, and that correction is remembered. Settings shows the router in order (neural check, Arch-Router, Śilpī-Laghu) with on/off switches and status. It also includes the 0.9.2 work, which was not published on its own: models are chosen by how fast they really run on your PC as well as by memory, so a poem or explanation is not sent to a model that crawls on the processor, and a model that turns out too slow while writing is stopped and replaced with a faster one, said plainly; the record of each answer names the model that really answered; a short instruction typed over a pasted task is read as one request; and Vāk is back to greetings, quick replies, spoken replies and the last fallback, with conversation and writing on the general writer. Everything in 0.9.1 stays. Windows is unsigned; the Android app is 0.8.8. 0.9.3 was checked with the offline test suite and an offline routing and handover check; the full live check on Windows was not run for this release.

Previous Windows release

Writing uses the strongest model that fits, nothing loads at startup, and Prāṇa trims idle apps before stepping down

Chitta 0.9.1 lets writing, explanations and careful questions use the strongest model that fits in your free memory, with the quick 2.6B model kept for greetings and short replies and as the last step down. Naming a model for one step now applies to that step: "study the nine devis on the web, write a prompt for each and pass them to Citra Uttama" researches with sources, writes nine prompts and paints nine pictures with Citra Uttama, while "draw a cat with Citra Uttama" still goes straight to Citra. When you paste your prompt as the whole message, Chitta now reads the pasted text as your request instead of asking what to do with it; pasted logs, emails and code under a typed request such as "summarise this" are still treated as material. Nothing is loaded when Chitta starts any more; a model loads for the first request that needs it, and an already-loaded quick model no longer decides which model answers. Prāṇa, the memory manager, now has a clearer view, opened from the RAM indicator at the top: a live memory bar with each loaded model, why it is loaded and an Unload button, the four freeing steps with the current one highlighted, what it last did in plain words, and a "Free memory now" button. When memory is tight, its last step first trims idle background apps the way RAMMap does (nothing is closed, the app you are using is never touched, and apps that need administrator rights are left alone and counted), then measures again, and only then picks a smaller model; one switch in that view turns the trimming off. A note about memory now shows the real numbers, and a slow CPU-only model is no longer described as low memory. The larger coding model gets its full working context when your memory allows it (on some PCs it was held at 8,192 tokens), and a picture made from the file in your previous message is no longer checked against Chitta's own reply text. Everything in 0.9.0 stays: Chitta 0.9.0 fixes making documents and running computer tasks. Asking for a Word document, PDF or report now makes the file, or says honestly that it could not; it no longer prints tool instructions in the chat, stops at "Paused after step 1", or picks the "Answer from a document" skill. Questions like "find the top 100 big files" are answered by a direct, read-only scan (nothing is deleted or moved) and the list is saved in your work folder. Commands that use PowerShell variables such as $_ now run correctly, and a long read-only command that runs out of time says "timed out, nothing was changed" instead of a scary paused message. When memory is tight, the light coder is used instead of looping, and the small conversation model never runs commands on your PC. Hasta (computer control) now takes over properly: it asks first, shows "Chitta is controlling your computer" with Pause and Stop, asks again before any system change, and always hands control back. Hasta files you already downloaded are checked and shown as installed in Models, with proper names. While an answer is being written, the text now stays visible instead of flashing and going dark. Answers now contain only what you asked for: notes about memory or which model answered stay in the closed "How I answered" section, an answer is never printed twice, and old unrelated chats are no longer pulled in as if they were new requests. Routing is fixed: coding requests such as "I need a website", "make a landing page" or "can you fix the code you wrote?" now go to Śilpī, the coding model, instead of the small quick model; naming a model (for example "handover to Citra Uttama") always uses it; and the file made in your previous message is handed to the next step automatically. Chitta no longer falls back to the small 2.6B quick model when a better model fits: Śilpī loads with its full working context, a long coding job steps down only to a smaller coding model, and a slow planning model is moved to the graphics chip instead of giving up. Prāṇa now has a live memory panel showing free RAM, which models are kept warm, and each step of its freeing ladder,. Everything from 0.8.9 stays. Windows is unsigned; the Android app is 0.8.8. Release note: checked with the offline test suite (932 of 939 pass; the 7 failures are known test-machine environment issues); the live check on Windows was still running when this was published.

Previous Windows release

Chitta no longer falls back to the small model when a better one fits, routing is fixed, and Prāṇa gets a live memory panel

Chitta 0.9.0 fixes making documents and running computer tasks. Asking for a Word document, PDF or report now makes the file, or says honestly that it could not; it no longer prints tool instructions in the chat, stops at "Paused after step 1", or picks the "Answer from a document" skill. Questions like "find the top 100 big files" are answered by a direct, read-only scan (nothing is deleted or moved) and the list is saved in your work folder. Commands that use PowerShell variables such as $_ now run correctly, and a long read-only command that runs out of time says "timed out, nothing was changed" instead of a scary paused message. When memory is tight, the light coder is used instead of looping, and the small conversation model never runs commands on your PC. Hasta (computer control) now takes over properly: it asks first, shows "Chitta is controlling your computer" with Pause and Stop, asks again before any system change, and always hands control back. Hasta files you already downloaded are checked and shown as installed in Models, with proper names. While an answer is being written, the text now stays visible instead of flashing and going dark. Answers now contain only what you asked for: notes about memory or which model answered stay in the closed "How I answered" section, an answer is never printed twice, and old unrelated chats are no longer pulled in as if they were new requests. Routing is fixed: coding requests such as "I need a website", "make a landing page" or "can you fix the code you wrote?" now go to Śilpī, the coding model, instead of the small quick model; naming a model (for example "handover to Citra Uttama") always uses it; and the file made in your previous message is handed to the next step automatically. Chitta no longer falls back to the small 2.6B quick model when a better model fits: Śilpī loads with its full working context, a long coding job steps down only to a smaller coding model, and a slow planning model is moved to the graphics chip instead of giving up. Prāṇa now has a live memory panel showing free RAM, which models are kept warm, and each step of its freeing ladder, and it can (if you turn it on) trim idle background apps the way RAMMap does, without closing anything. Everything from 0.8.9 stays. Windows is unsigned; the Android app is 0.8.8. Release note: checked with the offline test suite and a live check on Windows.