Changelog

Everything we've shipped, newest first — the IDE and the open-source local tool on one timeline.

August 2026

August 20FeatureLatest

Business logic you can watch, and the two prices of a change

The site now says what the product actually is: observability for software production with humans and AI agents. The audit is how much a change costs; the model is what the thing being changed does — areas, business objects, processes, states, rules, read from the code rather than written by hand.
New block on the homepage: what the model writes down, and the questions it answers that nobody prepared for — what breaks if the order status changes, which rules govern cancellation, what a task would touch that the ticket never named.
Every change is now drawn as one bar rather than two cards: cyan for the first pass, red for everything paid again. The split is measured; turning it into money needs your hourly rate, which is written on the page instead of assumed.
And the block after the audit says the picture is yours either way — most of what it shows is fixable by a team that can finally see it, and what we sell is having done it before.
The five rungs were renamed to what each one actually gives you: understand it, observe it, measure it, control it, scale it. Open source stops at the first.

August 20Feature

The measurement is free, and the pilot is withdrawn

Every change has two durations: the first version that could be reviewed, and everything between that and acceptance. Your tracker records one duration for both, so the expensive half has never had a number. That gap is what the site now argues about.
The $7,500 measured pilot is withdrawn. Connect produces the same evidence from work the team is doing anyway, and charging for the right to see your own numbers put a toll booth in front of the thing that sells the product.
Team and Enterprise no longer publish a starting price. Both are scoped against the part of the observed cost we and you agree is recoverable — which is a different number from what was observed, and the only one an offer may be built on.
The assumption calculator left the homepage. Asking a CTO to guess what fraction of their engineering is wasted is a weak question when the answer can be read off their own changes; it stays on /roi for anybody with no data yet, labelled as an estimate.
New: /audit explains what gets measured and why nobody has to log anything, and /audit-methodology publishes the definitions — including the idle cutoff, what is deliberately not measured, and where the method is still weak.

August 18Fix

The install instructions match the installer again

Open a new terminal between the two commands. The installer now writes the PATH line into your shell profile itself, but a shell reads its PATH when it starts — run both lines in one window and the second one is not found. The warning sits between the commands, where it is still an instruction.
Cloned the repository instead of installing? That route is now next to the main command rather than a footnote under it — the `gitmir` command ships with the installer, so from a clone it was never available, and that line was the instruction.
`gitmir check` starts the MCP server exactly as your editor does and prints what it answered. An MCP server has no window, which is what made a broken setup so hard to tell from a working one.
The install path is `~/.gitmir/local`, renamed with the repository; the installer moves an older install itself.

August 18Improvement

Connecting your agent is one command

How it works stopped telling you to copy a skill into the chat. After `gitmir mcp add` the twelve procedures arrive as slash commands and the fourteen tools are called by the agent itself — there is nothing left to paste.
The setup is four moves instead of three, and every move that can fail now says how to check it — including the editor restart, which is the single most common reason people decide the connection did not work.
The agent sets the project up itself: it adds the folder, creates the queue and reads the repository into the object model, because the setup procedure is a tool it can call.
The team key is no longer a step inside “add your project” — it is an optional line for the people whose work is watched. And the skills are still plain markdown you can copy by hand; MCP changes who does the typing, not what gets done.

August 16Feature

One line installs the open-source engine, and the line comes from here

It used to be clone, cd, run — a developer telling another developer what to type. Now it is one command per platform, with the second one (`gitmir`) shown right under it, because leaving that off is how a one-line install turns into a support question
ide.gitmir.com/install.sh and ide.gitmir.com/install.ps1 serve the scripts from the repository's main branch — proxied rather than redirected, as text/plain, cached five minutes and kept for a day so a GitHub outage does not take the install down with it. If there is nothing trustworthy to serve, the answer is four comment lines telling you how to install by hand: whatever these routes return goes straight into a shell, so it can never be an error page
No cookie, no pixel, nothing counted on those two paths. The product claims the absence of telemetry as a property, and an installer that behaved otherwise would cost more than the number it would collect
The footer now says the same things where anyone can find them: the engine is AGPL-3.0 with a commercial licence for closed-source embedding, there is no telemetry at all, and — precisely because there is none — the discussion thread is the only way we learn that it ran on your machine

August 16Design

Connect gets a screen of its own, and it plays

The block used to end in a still panel beside the copy: three developers frozen mid-task and a diagram of three boxes. It is now a full screen on the site's own render engine — the same product model the page opens on — and the scroll is its timeline
Six beats, and each one is the argument: three machines local and connected · each agent's name standing on the product area it is changing · a refund change reaching inventory, a dependency the ticket never named · Anna and Mark turning out to be inside the same object, flagged before either has executed · twelve affected areas and four open decisions in front of the whole team · the result checked against the intent that was approved
The team console is drawn on the model rather than beside it, because every row of it is about an object in the graph: who is connected, what each agent is doing right now, what just happened, what is waiting on a decision, and the counts once all of them are true
Every word on it comes from the site's own dictionaries, so the console plays in Russian and Ukrainian too — the renderer draws, the page supplies the copy

August 16Fix

The ROI calculator is an ordinary page again

It used to be mounted inside a fullscreen shell: the document scroll was locked and the calculator scrolled inside a fixed overlay of its own. It looked like a product demo and behaved like a bug — the wheel talked to an inner box, the scrollbar belonged to nobody, and anchors, page-down and find-in-page all landed in the wrong place. The page now scrolls the way every other page does
The line that swept down the screen is gone with the shell it belonged to. Nothing on the page moves on its own any more
Everything that made the page worth reading is unchanged: the presets, the quick and detailed modes, the result as a range rather than one confident figure, the evidence level stated on the result, one measured change with its baseline frozen, and the ladder that says what a calculator is allowed to claim

August 13Design

Pricing is two halves now: a product you start yourself, and work we do on your system

One comparison matrix used to put all four plans in the same shape — the same product with more ticks further right — so the only question it left a reader with was why $24K beats $19 times the team. It is not more of the same thing, and the page no longer pretends it is
Community and Connect stay as they were: a price, what is in it, and a button. Nothing to schedule, nobody to talk to
GitMir Team is described as what it actually is — customization of the system: the model of your product built with your team, connectors to the services you already run, the check inside your pipeline, your own rules written down as verification contracts, and a named engineer rather than a ticket queue
Enterprise is described by what it removes: the week of syncs and hand-assembled status reports. What changed, what it touched, who decided it and what proves it are already in the model, so the answer is a by-product of the work instead of a task on top of it. SSO, private install, residency and audit are still there — as the conditions to start, not as the pitch
The pilot is now the first integration rather than a trial: one real change, on your stack, wired to one of your services, and it counts toward the year if you carry on
A new section before the price says why us, and answers it with the repository rather than a claim: the engine is open, it runs without us, and whatever we build for one company goes back into the core — so the next team gets it for nothing and the following engagement costs less
A block for organizations names the four people who lose time to four different expensive questions — engineering leadership, delivery, whoever faces the client, and compliance — and for each one: what that question costs today, what the view built for it answers, and the shape of the answer. The examples say on the panel that they are examples: those views are what an implementation builds, and a mock-up presented as a shipped screen would cost exactly the credibility the section above it argues for
And the business model is drawn rather than implied: one open core, two ways to take it — run it yourself, or have it implemented with you. Your workflow is custom, the platform is shared

August 12Design

GitMir Core on the homepage, and the freelance side moved to its own product

A new section says what the context underneath everything actually knows: what exists, which objects are linked, what is a fact and what is an assumption, what was decided, what contradicts what, what changed and why, what follows from it and what proves it — each line with where it lives, because ten claims with nothing behind them argue against a page about a source of truth
And why it is open source: a source of truth nobody can inspect is somebody's private opinion about your software. Around one and the same context sit different products — the local app that builds it, the team layer that shows it
The developer directory, the job board and the operator path left this site: they are their own product now, with their own front page and their own sign-up. The old links redirect there rather than 404 — they are in search results, in messages and in profiles people filled in
The half of that which belongs to an account stays here: opting into the directory, your public profile and the work requests you receive are still in Settings

August 12Improvement

A shared map drawn by the tool itself, and the skill cards say what the tool now says

A shared link used to be laid out by a graph library and painted as SVG: a competent diagram, and a different picture of the same product from the one in the local app. It is now drawn by the app's own canvas renderer, vendored from the open-source repository rather than imitated
Four views again, each with its lines back: the product map, where an area opens into what it contains; the business logic of a process end to end; the records and what links them; and where data comes from and where it goes
What the browser is handed is a narrowed copy of the model — the wiring survives so the diagram has edges, the words do not: no file paths, no routes, no column names. The first cut of this stripped too much and produced boxes with nothing between them, which is not a map
The eleven skill cards on “How it works” were refreshed from the tool: the model is described as the single source of truth for what the product does — everyone working from what it IS rather than what they remember, which is where most mistakes start

August 10Fix

The set-up steps no longer vanish before you have connected anything

"Connected" meant "a key exists", so pressing Show my key — step 2 of three — marked you as done and the instructions were gone on the next load, before anything had been run. It now means a machine actually attached to the relay
While it waits, the page says so and checks by itself: the moment your machine attaches, the steps collapse into one line that says it worked
Until that first machine, the page is a set-up page: the card explaining why the queue is empty no longer sits directly under the instructions you are meant to follow. In its place is what will appear there once the machine is on — the queue, the product map, and what each task will touch
The key, the relay address and the project id can be copied in one go, in the order the local app asks for them
The project menu held a single item linking to the page you were already on; it is gone until there is somewhere else to go
Creating a project no longer throws you out of the conversation after two seconds: the three steps arrive in the thread, with your key, and opening the project is a button you press when you are ready
The cabinet switches to the language you are writing in instead of staying English after a whole conversation in Russian

August 10Improvement

Starting a project now offers what the local app can actually do

The onboarding conversation was describing a product that no longer exists — it promised the agent connects "in one step, in Docker on Windows", a flow whose code was removed when GitMir became open-core, and it offered sixteen project types, eleven of which (a beautiful site, a game, a browser extension) had no skill behind them
There are six starting points now, and each one is a set of skills the local app carries: build something new from a description, a spec or a dataset; work in a codebase you already have; change inherited code without breaking what is next to it; port a working project to a new stack at parity; audit a running app by proving what a user can actually do; or keep the map in sync while you write the code by hand
Every one of them gets the same thing on top — before a task runs, what it will touch
It asks where the code is when there is code, and records the repository on the project
After the project is created it points at the three steps the project page really shows: install the free local app, take your key, point the app at this project

August 6Feature

A shared map you can actually read: four views, and six more named

A shared link and /p/<id> now open a real diagram rather than a list: product map, business logic, data, and journeys — each with zoom, fit and full screen
Six more views the local tool draws are named and locked rather than hidden, so nobody has to guess what they are missing: impact, data flow, decisions, events, timeline and overview. They need the tool on your own machine
/p/demo is a real project, not an illustration — DevPlan, a construction-programme tool: 12 areas, 16 kinds of record, 4 lifecycles, 31 screens, 81 endpoints. GitMir read the repository in 35 minutes and drew this
The shared view stays narrowed: areas, records and lifecycles by name; field names, endpoints and the steps inside a flow are counted, never listed

August 6Feature

Open source: the local tool answers what a change will do, not only how the product is wired

Impact is the new tab in the local tool: pick a change and see what it touches, at a grain somebody can act on — areas, records, the flows that run through them
It works before the work exists. Approve a change before it is built, or estimate one that has no task yet — the point is to argue about scope while arguing is still free
The model now says where an object lives and when it was recorded, and it notices when it has fallen behind the code. Refreshing it is a check the queue runs, not a habit you have to remember
A project opens on the map rather than on a list of files

August 5Design

Open source: the local tool looks like the IDE, because it is the same product

Projects as tiles, a tool rail instead of tabs, and the IDE's own icons and cards rather than an approximation of them
Skills are a grouped grid of plates with a picture each, and the rail carries the queue count
Two things had been quietly broken for a while: the design tokens were never actually declared, so half the system was inert, and the corner brackets were not rendering at all

August 5Fix

Five things a real phone found

A 404 page of our own. The entire site had none — a mistyped URL landed on the framework's default
Settings on a phone: the section list collapses instead of eating the screen before you reach the setting
Ghost buttons look like buttons on a touch screen. There is no hover on a phone, so a control whose only affordance was the hover state read as plain text
A Google account can set its first password — it is asked for twice, and never asked for a current password that never existed
Referral sources stop collapsing on top of each other on a narrow screen

August 4Feature

Share the map by link — free, on every plan

Two doors to the same thing: Share in the cabinet, and Share this map in the local tool. Either produces a link that opens without an account
Link or named people, and the mode can be changed or the link revoked at any time
There is no plan check on this and there will not be one. A map somebody can open by link is free — the paid part is the bridge that connects a team's machines, and that is a different question
One fix worth naming: links built by the local tool carried its bind address, so they came out as https://0.0.0.0:8882/s/… — every link anybody had made that way was dead on arrival

August 4Feature

Say the task out loud

Dictate a task with the browser microphone, in any project
The recording is transcribed and turned into a title, a description and acceptance criteria. You see all of it and edit it before anything is created — nothing is filed behind your back
The site's own permissions policy was blocking the microphone before the browser could even ask for it

July 2026

July 31Improvement

Open source: what the local tool is made of, in writing

AGPL-3.0, with a commercial licence alongside it for anybody who cannot take that one
A security document that says what the tool is actually made of: what it reads, what it writes, what it sends and where
TypeScript on modern Node, ESM imports, no build step. Clone it and run it — there is nothing to compile before you can read what it does
Every artefact an agent writes is in English, so a mixed-language team is reading the same thing

July 30Feature

Open source: nothing is done until its checks pass

The queue has a verify stage. A task is not finished when the agent stops typing; it is finished when the acceptance criteria written with it have been checked
Per-criterion results travel to the room, so the browser shows which check failed and why — not a status word
app-audit: a skill that walks the whole app, proves every use case, and files what fails. The gaps are reported first, then the defects
Preview: open any URL, click an element on the page, and get a task that names the code behind it
A product map built from sources too big for one read, navigable by id — so a large repository stops being a reason not to have a model

July 30Feature

The operator path is open, and every step on it is earned

/operator is the whole thing in five steps: your machine connects, you finish one task, its acceptance checks get run, you publish the level of responsibility you take, and you answer a job
Not one of those can be completed by claiming it. Each is read from work that actually happened — a relay key that has been USED, a task your machine finished, checks your agent reported on. Minting a key proves nothing; anybody can press a button
A run whose checks FAILED still counts. It proves the loop closed, and demanding a clean run would teach people to write criteria that cannot fail — the opposite of the point
Six landing pages that used to collect an email now point at it, each suggesting the level it was written about. Suggesting, not preselecting: which level you take is the one decision on that page nobody should make for you
That takes /products to 16 live of 20. What is left is honest about why: two need a fortnight of real use, one needs the money question answered, and the Network itself should stay last

July 30Feature

Agreements, where the level is the term and not a word in an email

Accepting somebody's application now leads somewhere: “Agree the terms” records who, at what level, for what scope and at what price — prefilled from the post and their own quote, because retyping what you both already said is how the numbers stop matching
The level of responsibility is the contract term. It cannot exceed what the operator has published, checked when the terms are written and again when they are confirmed — a level somebody withdrew in between cannot be agreed
Both sides agree, in that order. Whoever wrote the terms cannot also accept them: a record one person made alone is not an agreement, however it is labelled
Finishing takes both too. Either of you can say the work is done; it counts as finished when the other agrees. One-sided completion is how “I considered it delivered” turns into an argument
GitMir records what you agreed so you are both looking at the same terms. It still does not hold, move or release the money — you pay each other directly

July 30Feature

An open board where a job carries the checks it will be judged by

/jobs is open. Describe a job once and every operator sees it, instead of finding one person and writing to them — that is the difference between a pipeline and a mailbox
A post cannot be published without the checks that decide when it is done. You write them before anybody quotes, the operator prices against them, and the same list is what their machine reports running when the work is finished. A brief with nothing to check against is refused
The level of responsibility is part of the post, and you can only apply at a level you have published — checked against the database when the application is sent, not against whatever the page was showing
Every post is read by a person before it reaches the board, and a post that is turned down tells its author why
GitMir still does not hold or move money. The budget on a post and the price on an application are claims; you agree and pay directly. Every page here says so

July 30Feature

A record of work that shows the checks that failed

A public profile can now carry a record built from tasks that person's machine actually ran: what was asked, which acceptance checks were run, which passed, and which failed with the reason the machine gave
Failures are part of it and always will be. A history with no failures in it is marketing, not history, and hiding them would destroy the only thing that makes this record worth reading
Two switches, both off by default and both required: the project's owner allows work done there to count (project page), and the person allows their own record to be published (Settings → Public profile)
Nothing is stored. The record is computed on read, so switching either consent off hides it on the next request and leaves no copy behind
Attribution comes from the authenticated connection, not from the message — a machine cannot claim work it did not do

July 30Fix

Everyone the directory lists can now actually be invited and hired

When the directory became opt-out it started listing everybody, but three checks were still asking "has this person published a developer profile?" — so inviting or contacting 27 of the 28 people on the page dead-ended with "this person is not in the public directory". They now ask the question that actually applies: is the account private
The same check gated avatars, so an uploaded picture would not have been served on the directory that shows it
The work inbox no longer says "you are not in the directory" — everyone is. It now names the real reason nobody can send you work: you have not published a level of responsibility
Clearing your task queue on your own machine now clears the mirrored copy too. It never did: the delete used a NUL byte as a sentinel, Postgres refuses those outright, and the error was swallowed — so a queue you emptied kept showing tasks in the browser

July 29Feature

Hiring an operator is live — the pages that promised it stopped saying “not open yet”

You can browse /developers, filter by the level of responsibility you want, open a profile and send that person the job — with the level, a budget and a date. They accept or decline, and you see which
Asking somebody for a level they have not published is refused rather than quietly accepted, so the level on the request means what it says
Two product pages, Hire an operator and Levels of responsibility, are now marked LIVE and their buttons go to the directory instead of collecting an email
GitMir does not hold or move the money. You pay the operator directly, as you would any contractor — every page that touches hiring says so, and will keep saying so until it stops being true

July 29Improvement

The directory now lists everyone — and anyone can switch it off

Everyone with a GitMir account appears at /developers. A directory nobody is in is not a directory, and the network needs a supply side to exist at all
Only a name and avatar are shown until someone fills in a profile themselves. Email addresses are never published — the public pages do not even read them from the database
One switch turns it off: Settings → Public profile → Private account. It removes you from the directory and from every public page immediately, and your profile link stops resolving
Every user is being emailed about this, because it changes what is published about them

July 29Fix

Inviting someone into a project actually works now

Somebody who has just joined now sees three steps on the project page: install the free local app, take their own key, point it at this project. It shows only for people who can build and have never connected, and disappears for good once they have — viewers never see it, because a viewer installs nothing
There is an Invite card on the project page. It was only in workspace settings before, so a fresh project had no way to add anyone from the page you were standing on
A person with no GitMir account can now accept an invite with email and a password. Google used to be the only way in, so anyone without a Google account hit a dead end on the exact link meant to bring them into the team
Signing in from an invite keeps the invite. It was dropped on the email path, so you could register successfully and land in an empty workspace list, having lost what brought you
Accepting takes you to the workspace with the project in it, not to a list to search through

July 27Improvement

Get told when we ship, without watching this page

Leave an address at the top of this page and you get one email per release — nothing else, ever
You confirm by clicking a link first: nothing is sent to an address that has not confirmed, so nobody can put you on this list but you
Every email carries a one-click unsubscribe, and the changelog itself stays public — you can read it any time without giving us anything

July 27Feature

Ask for something — a task written in the browser lands on the machine

The bridge now runs both ways. Anyone on the project — a teammate, a manager, the client on a phone — writes a task in the browser and it lands in the developer's local task folder as a file, the same way a task from a teammate's laptop does
Acceptance criteria come with it. Write "Done when" lines and they go into the task file as its acceptance criteria, so the agent can run them and you see which passed
If the machine is offline the task waits and is delivered the moment it connects — but only when the project's level already allows the task feed to be stored. At level local nothing is kept, and you are told plainly that it was not delivered rather than being shown a cheerful "Sent"
Nothing runs because a task arrived. It becomes a file in the developer's queue; they decide what their agent picks up, and when

July 27Feature

Watch the work from a browser — and see the evidence, not a status word

The project owner decides what leaves the machine: nothing (the default), the task queue, or the queue plus the product model. Source code is never uploaded at any level — there is no setting for it and no endpoint that accepts it
Lowering the level deletes what was already stored, in front of you, rather than hiding it
A client who installs nothing can now follow the work from a phone or a laptop: what is running, what comes next, and what each task must satisfy to count as done
Tasks now have a fourth state — being checked — for the moment the agent has written the change and is verifying it against the acceptance criteria. It is never counted as done
Where the agent actually ran the checks, the page shows how they came out: “3 of 4 checks passed”, the failing one by name, and the reason it gave. A check that was blocked or never run is reported as failing, never as passed
When the agent retries a task that failed its checks, the retry says which task it is retrying and which attempt this is

July 27Feature

Developers directory, and hiring through GitMir

A public directory at /developers — opt-in, and off until you turn it on. Your email is never published, and your CV is visible only to signed-in visitors
Your profile carries an avatar, a CV, and the skills you claim with the level you claim for each
Three ways to work: run an agreed brief as-is, add QA against the brief's acceptance criteria, or add architecture and the brief itself
Teams on the Team plan can invite a developer straight from their profile

July 27Design

A new home page, and $19 per developer

The home page no longer hijacks your scroll: it is a normal page you read at your own pace
Pricing is stated plainly — alone on your own machine GitMir is free forever, and you start paying at the moment a second person needs to see the work
$19 a month per developer. Viewers are free and unlimited on every plan: a client, a manager or an investor never costs you anything

July 25Feature

Team bridge: your team's machines, connected

One person builds a product locally; their teammates see the model that machine shares and send tasks straight into its local queue
The room is the PROJECT — a team with several products gets a separate channel for each, not one shared feed
The relay only routes between your machines and stores no business logic: your code and your model never sit on our servers, which is what makes this usable under an NDA
Each member connects with their own key, taken from the Team bridge panel on the project page
Included in the Team plan

July 25Improvement

GitMir is local-first: your code never leaves your machine

The product model, the task queue and the build itself now run in the free open-source GitMir tool on your own computer
Our servers keep only your account, your team and billing — nothing about your product
Removed from the hosted app the parts that reached your machine: the MCP connection into your local Claude, the connector and one-click launcher, the in-app preview and product deployment
This is not a policy but the architecture, and the tool is open source, so you can verify it yourself

July 25Improvement

Simpler pricing: Free, Team, Enterprise

Three plans instead of six. Free is solo and free forever; Team is $19 a month per builder and includes the team bridge; Enterprise is by agreement
Viewers stay free and unlimited on every plan — watching what a team builds never costs anything
Build Credits are no longer sold: after the move to local-first nothing in the product could spend them. Balances already granted are untouched

July 25Design

Open source, in plain sight

An Open source button in the site header and on the first screen, pointing straight at the public repository
Retired the onboarding lab scene from the home page: it sold the old hosted-build story and flashed its question on every scroll past it

July 24Improvement

Meet AI becomes its own product

The meeting engine — live transcript, the semantic graph of decisions and the tasks it produces — has moved out of the IDE into a standalone product
It will connect to whatever tool your team already uses over MCP or a plain API and push the tasks and the structure there, instead of only into GitMir
A meeting is inherently a cloud event, so keeping it inside a local-first IDE no longer made sense

July 16Fix

Windows (Docker) connect command now runs cleanly

Fixed the Windows connector: PowerShell could error on the setup script (“FROM is a reserved keyword”) because of how the Dockerfile was embedded — it now runs cleanly in Windows PowerShell

July 15Improvement

Create a project even if the AI assistant is unavailable

Project creation no longer depends on the AI onboarding assistant — if it's ever unavailable, a manual form appears automatically so you can create the project from a name, a project-type dropdown, and a short description
The manual path lands on the exact same connect step (Claude Code / Codex + one command), and supports every project type — including recreate-from-URL and legacy migration

July 14Fix

Chat now tells you when no agent is connected

If you send a chat message before connecting your Claude Code, the chat now says so clearly and keeps your message — instead of spinning on 'picking this up…' forever with no explanation
Message and chat endpoints now always return a clean response, never an unexpected server error, even on older data
Added an app-wide safety net so any unexpected error shows a small 'try again' panel instead of a blank error page, and hardened the chat so no reply can ever break the screen

July 14Improvement

Tasks now run at extra-high reasoning

The connector now launches Claude Code with --effort xhigh — a real step above the default, so tasks reason deeply and stop skipping elementary details on fixes (it was running at the model's default effort before, despite the label)
Every task prompt now explicitly tells the agent to think through the whole change end-to-end — trace callers, side effects and edge cases, then re-read its own diff — before finishing
Reconnect your Claude Code (relaunch the connector) once to pick up the higher effort

July 14Improvement

Tasks now distribute across your business-logic modules

Every planned task is now routed to a real business-logic module: the platform resolves the module by its stable key (not just its name), and creates it — or a shared “General” lane — when needed, so tasks never silently pile up unassigned
New “Group by → Module” board view: swimlanes, one per module, show your work distributed across the product’s business logic at a glance — drag a card between lanes to reassign its module
The AI task composer now lets you pick the module a task belongs to, defaulting to the module you’re viewing
Claude Code is asked to tag every plan task with its module, and each plan now reports how many modules it spans

July 13Improvement

Clearer task tracker, exact token usage, and connection alerts

Every finished task now posts a completion report to its thread — a plain-language recap of what was done, the files it changed, and one-tap follow-ups — so you can see at a glance when it finished and with what result, in the task and in chat
Task tracker: both the list and the board keep a stable, meaningful order (by priority, then oldest first), each task is tagged with its business-logic module, finished work lands in Done (not stuck in Review), and every task shows the engine it runs on — Claude Opus 4.8 at high reasoning
Exact token usage is now reported straight from your local Claude Code — the Context page shows real output/cache numbers plus what drives the spend, tool by tool
A banner now warns you the moment your Claude Code isn't connected — on open or if it drops mid-build — so tasks never silently wait
Chat: a wider, more readable thread that opens your most recent conversation, plus one-tap “Run next” prompt suggestions from the agent
The public site remembers you're signed in — the top button becomes “Open app” and takes you straight to your workspace

July 12Feature

Coming soon: GitMir for VS Code & Cursor

We're building a GitMir extension for VS Code — and Cursor — so you can drive a project from your editor: connect, watch the live task queue and build, and run Claude Code without switching to the browser
Approve or deny privileged actions right where you work, and jump from chat straight into the schema or a task
Publishing to the VS Code Marketplace soon

July 12Feature

Project chat is now interactive

Claude Code answers with tappable options, checklists, cards and buttons instead of walls of text — pick an answer in one tap and the conversation continues
Ask a question and get a decision menu, a mini-form for real values, a progress checklist, or a card that jumps you straight into the schema or a task
Replies stay short and structured, so chats read easily and use far fewer tokens

July 12Improvement

Faster, cheaper, more reliable builds

The agent reads only the slice of the product model each task needs, instead of re-analyzing the whole model every time — big token savings
The local product model is split into per-topic files (entities, routes, functions…), so the agent opens just what it needs
Removed duplicated data from the context the agent loads, roughly halving that payload
The build loop can no longer get stuck retrying forever — a hard ceiling stops runaway rounds
The agent is nudged only when it's idle, so it's never interrupted mid-work

July 11Feature

New page: run GitMir on your team's subscriptions

A new Subscription page explains how to stop renting API tokens and build with the Claude Code / Codex subscriptions your team already pays for — across every developer machine

July 5Fix

Settings: honest usage counters and easier navigation

Billing now counts what the plan actually limits — private projects only, per workspace; public projects and viewer seats stay unlimited
A clear Back button returns you exactly where you came from
Toggle switches sharpened to match the design system

July 5Feature

Meeting bot goes multi-platform: Meet, Zoom, Teams, Webex

The Meet AI bot now runs on hosted meeting infrastructure — paste a Google Meet, Zoom, Microsoft Teams or Webex link and send it in
Live transcription no longer depends on meeting captions: the call audio is transcribed directly, speakers included
Meeting data is processed in the EU region

July 5Feature

Buy External AI Credits without leaving the IDE

The credits chip in the header now opens an in-IDE popup: balance, three packs and per-action pricing — no detour through the pricing page
Credits are one global balance shared by all your workspaces; checkout returns you to the exact page you started from, with a green “added” pulse on the chip

July 5Design

Project preview images & a sharper Meet AI

Upload your own preview image for a project — it replaces the colour tiles in the header, sidebar and project cards
Meet AI polished throughout: HUD framing, a larger readable graph, diamond accents instead of raw glyphs and a consistent spacing grid
The Share map button on Overview is now cyan with a white hover

July 5Feature

Meet AI: your meetings become architecture

Send the GitMir bot into a Google Meet — it transcribes the call and builds a live map of systems, entities, decisions and contradictions while you talk
Conflicts are surfaced, never auto-resolved: pick the winning claim and it becomes a recorded decision
One click on Apply to Project turns what you agreed into real tasks — your connected agent starts executing immediately

July 5Feature

Observer projects: a live map while you code by hand

New project kind: the agent never creates build tasks — it continuously mirrors your hand-written code into the product map
The map syncs to .gitmir/model.json locally and to every GitMir screen; share it with anyone via the public map link
Build-pipeline tools are blocked server-side for observer projects, so the map can never turn into an unwanted build queue

July 4Feature

Watch free: public project maps

Share a live, public map of any project — one toggle in Overview, one link for anyone
Public projects and viewer seats are now unlimited on every plan — limits only count private projects and builder seats
Refreshed home page with a new founder video hero

July 3Improvement

Workspace customization & a sturdier connector

Rename your workspace and set a custom cover image
Connector hardened: clearer install logs, automatic fallbacks, no more interrupted sessions mid-generation

July 1Feature

8 new project types

Start a premium Website, AI product, Automation, Audit, Mobile app, API service, Game or Browser extension — each with its own build playbook
Onboarding detects your project type automatically and tells you exactly where to run the connector
Live Preview works on Windows with a dedicated port per project, auto-detecting the real dev-server port

June 2026

June 30Feature

Create projects by chatting

The new-project wizard is gone — describe what you want in a guided conversation and GitMir sets everything up
One continuous journey: chat, connect your agent, land in the Control Room
The assistant replies in your language and covers all project types

June 30Improvement

Lower token costs & a full build audit trail

Smarter context loading: lazy, layered model delivery and sampling of large codebases cuts real token usage
New Audit tab on every task — a timestamped, reproducible record of what the agent did
Overview gains a unified Build Status dashboard

June 29Feature

Windows support with a sandboxed Docker connector

One-line setup on Windows: the connector runs in Docker with instant task pickup
Choose the mount scope — project folder only, or the parent folder for sibling repos
New pre-execution action policy: risky agent actions are checked against your boundaries before they run

June 28Feature

Live Preview: click your product, get a task

See your product running live inside the IDE while it's being built
Click any element — GitMir resolves it to the exact component and files and turns your note into a task
New autonomous build pipeline: machine-checkable acceptance criteria plus a verify-and-reconcile loop

June 28Feature

New pricing: memory free, intelligence metered

Reworked plans: product memory is free, you subscribe for scale, AI work is metered with Build Credits
Buy credits right from the pricing page; your balance is always visible in the IDE header
Full mobile pass on the landing and pricing pages

June 27Improvement

Cleaner Connect, Overview and task screens

Connect is a tabbed dashboard (Connect · Build Timeline · Activity) with a chat-style live activity feed
Overview reorganized into calm, low-noise tabs
Multiple chat threads per project; the agent creates real tasks straight from bug reports in chat

June 26Feature

Flows: trace cause and effect through your product

Visual Builder gains Flows mode — follow any event, screen action or scenario through the data it touches
Live instance highlighting answers “where is this order right now”
Jump between the product Map and Flows with cross-navigation

June 26Feature

macOS desktop app & instant task pickup

New Downloads page with the GitMir IDE macOS app (Apple Silicon)
Realtime worker channel: a connected agent is nudged the instant you queue a task — no polling delay
New Product Brief with a distillation gate keeps messy source documents from poisoning the build

June 25Feature

Visual Builder: a drill-down map of your product

Explore your whole product as an interactive map — every node clickable with full detail panels
Edit the schema visually: new modules and business processes become build tasks
Slimmer navigation with a collapsible icons-only rail

June 24Feature

One-click connect & desktop building

Personalized launcher: one command creates the folder, registers the MCP server and starts your agent
Desktop app: pick a project folder, build in an embedded terminal, reopen it anytime as a dockable console
New projects open with a guided connect flow and unlock the full interface the moment your agent links

June 24Fix

Your plan now covers all your workspaces

Subscriptions are global per account — your highest plan governs every workspace
Fixed duplicate accounts from Google sign-in with different email casing
Stuck tasks resume automatically instead of blocking the queue

June 23Feature

How it works & the Solutions catalog

New How-it-works page: 9 fullscreen video scenes from new project to live product
New Solutions catalog: browse 101 ready-made products with search
Landing gains Teams & multi-dev and External Agents API scenes

June 21Feature

Agent API & prices cut in half

External AI agents can create projects, read the model and queue tasks over REST with per-workspace API keys
All paid plans repriced from $19/mo, limits raised 2–2.5×

June 20Feature

Use cases & ROI calculator

New use-cases section with 9 real customer scenarios, each with its own page
New ROI calculator estimates your savings and generates a full report

June 18Improvement

Attach files to any AI task

Add images, PDFs and text/markdown in the Task Composer — the agent receives them as part of the task's context
Uploads are staged safely and linked atomically, so nothing is lost if creation fails

June 17Feature

Proactive next steps & spec documents

When the queue drains, the agent proposes improvements — confirm one and it becomes a build
Attach up to 20 PDF/Markdown spec files when creating a project; the agent reads them directly
Two new project types: Blueprint (modeled on a reference codebase) and Companion (integrates with your existing system)

June 16Feature

Bring your own agent: Codex, Cursor, Gemini CLI

Connect supports Codex, Cursor and Gemini CLI alongside Claude Code, with ready-to-paste configs
Security hardening: signed webhooks, role-based access on the agent protocol, rate limiting, CSRF and prompt-injection guards

June 15Feature

GitMir speaks English, Russian and Ukrainian

Full three-language coverage: landing, all app screens, emails, legal pages and diagram labels
Your language is detected automatically, with a switcher in the header

June 12Feature

Bring your own codebase + visual canvases

New project type: onboard an existing codebase — GitMir analyzes it area by area, then develops inside it
New Frontend data-flow canvas and Backend services canvas visualize your app's real structure
Big performance wins: cheaper polling, lighter animations, faster graphs

June 11Improvement

Native-feel mobile & smarter big-project workflows

Mobile feels native: bottom tab bar, slide-up sheets, swipeable kanban, 101 polish fixes
One-click full API and integrations inventories sweep every layer of a large product into the model
An AI sales assistant joins the landing page

June 10Feature

Talk to your agent: task chat & plan review

Two-way conversations on every task — comment, get answers, and replying re-opens the work
Project Chat: ask anything about your product and questions jump the build queue
Review mode holds the generated plan for your approval before any building starts

June 10Feature

Teams & parallel multi-developer builds

First-class teams: invite by email or link, connect teams to workspaces
Every teammate gets a personal agent key — route tasks to a specific person's agent or let the pool pick them up
New model layers: status pipelines and cause-effect data rules, drawn as flows

June 9Feature

Full product builds, task by task

Describe, link or migrate — every project turns into a real build plan the agent executes one verified task at a time
Migration rebuilt: clean rebuild on your chosen stack, optional 1:1 frontend and database porting
Notification bell for approvals, one-click batch automations, and a Run Locally button

June 8Improvement

Simpler connect & sharper task context

Connect reduced to a 2-step wizard that collapses once your agent is linked
Each task ships with a relevant slice of the product model instead of the whole thing — compact prompts even on huge products
The model grows iteratively as tasks complete, with incremental merging

June 7Feature

Plans, billing, Task Composer & one-click deploy

Subscription plans with Stripe checkout, seat limits, and team invite links with roles
AI Task Composer: write a task in plain language and GitMir wraps it with product context, rules and a checklist
One-click deployment to a live domain, plus a referral program paying 40% of referred purchases

June 5Feature

Sign in with Google & the analysis loop

Google sign-in with automatic personal workspace setup, plus privacy policy and terms pages
Describe your business — the connected agent analyzes it into a live information model as you watch
New Logic view: a high-level map of your business modules and the data flowing between them

June 4Feature

GitMir IDE launches

First public release at ide.gitmir.com — the control plane that gives AI coding agents real product context