Changelog

Summary

Signing out of the phone app and then immediately signing back in could sometimes bounce you right back to the sign-in screen, even with the correct password. That's now fixed — signing out and signing back in work normally every time.

What You Gain

Previously, the app could keep signing you out automatically for a few seconds after you signed back in, showing the dashboard briefly before returning to the sign-in screen, sometimes more than once. You no longer need to wait, retry, or reopen the app to get back in.

How It Works

The app now finishes removing your previous session from push notifications before completing sign-out, and only treats a sign-in as expired when it's genuinely no longer valid — so signing back in right away is no longer mistaken for an expired session.

Where to Find It

This fix is already live for every user on the current app version — just update if you haven't already.

See the Effigate Command Center changelog for more, or try Effigate Command Center on your phone.

A new LogZuno project can now go from completely empty to tracking real events in minutes, with an install page that proves tracking is actually working before you write a single line of analysis code or wonder whether anything arrived at all.

What You Gain

Setting up event tracking usually means picking a library, writing boilerplate, and waiting to find out if anything actually arrived. LogZuno's install page removes the guesswork: it creates a project key, offers a snippet in whichever language or framework the site already uses, and then waits on screen and tells you the moment the first event shows up. Until real traffic arrives, a project can also load realistic sample data, so a new account always has something to look at, and that sample data is clearly marked and removable with one click.

How It Works

The install page offers the LogZuno JavaScript SDK as a script tag or npm package, plus ready-made code for cURL and a dozen other common ways to send events, each filled in with the project's own key. Add the script tag or snippet, load the page, and the install screen switches from waiting to "Data is arriving" on its own, no refresh needed. From there, the LogZuno SDK batches and retries events automatically, tracks pageviews (including single-page app navigation) and clicks without extra code, and works equally well from a browser or a server. Sample data can be added for a quick look around before real traffic exists, and removed later with one click, without affecting anything real that has already been tracked in the meantime.

Where to Find It

Open any new project to reach its install page, or revisit it later from Project Settings to add or remove sample data.

See how to invite teammates to help set this up. Learn more about LogZuno at logzuno.app.

LogZuno now lets you sign in or sign up with your existing Google or GitHub account, instead of creating and remembering another password.

What You Gain

Setting up a LogZuno account used to mean picking yet another password to create and remember. Now the login and sign-up pages offer a one-click button for each account your organization has turned on, so you can get into LogZuno the same way you already sign in everywhere else. If you already have a LogZuno account under the same email, the first Google or GitHub sign-in links it automatically once you confirm your password — so you end up with one account, not two.

Your account stays protected

Connecting Google or GitHub does not weaken your account's security. If your LogZuno account has two-factor authentication turned on, you still have to pass that challenge after signing in with Google or GitHub, exactly as you would with a password. And a Google or GitHub account is only ever linked to an existing LogZuno account after you type that account's password once — nobody can silently take over an account just by controlling an email address.

How It Works

The first time you sign in with Google or GitHub on an email LogZuno hasn't seen before, a new, already-verified LogZuno account is created for you — no separate email confirmation step needed. If that email already has a LogZuno account, you are asked to confirm its password once, and from then on either provider signs you straight in. Only Google and GitHub are supported today, and only the providers your organization has turned on appear as buttons.

Where to Find It

Use the "Continue with Google" or "Continue with GitHub" button on the LogZuno sign-in and sign-up pages, or manage the connection any time from Settings → Security → Connected accounts, where you can connect or disconnect each provider on its own. This is available on every LogZuno account at no extra cost.

Connected accounts build on the organizations, roles and invitations your team already uses to control who gets into LogZuno. Learn more about LogZuno at logzuno.app.

A command palette now lets you jump to any project or settings page in LogZuno without clicking through menus.

What You Gain

Finding a specific project or settings page in a growing list of organizations and projects can mean several clicks before you land where you meant to go. Pressing ⌘K (Ctrl+K on Windows and Linux) opens a search box that jumps straight to any project, or to project settings, channels, members, billing, API keys, security or sign-out, from anywhere in the app.

How It Works

Typing a project or page name filters the list as you go; selecting a result navigates there immediately and closes the palette. A visible "Search ⌘K" button in the header is always there as a reminder the shortcut exists, for anyone who prefers a click over a keyboard shortcut.

Where to Find It

Press ⌘K or Ctrl+K anywhere in LogZuno, or click the Search button in the header.

Learn more about LogZuno at logzuno.app.

A LogZuno organization can now hold a whole team instead of just one person. Teammates are invited by email, each one gets their own sign-in, and each is given exactly the access their job needs rather than sharing a single account and password between everyone who needs to see the data.

What You Gain

Before, there was no way to bring a team into one LogZuno account without sharing a single login. Now an organization can invite as many teammates as it needs, each with their own sign-in and their own role. An owner or admin keeps control of billing, API keys and membership, while a member works day to day in the projects and a viewer can check dashboards and reports without being able to change anything. Removing someone's access, or handing ownership to someone else, takes one action from organization settings instead of changing a shared password.

How It Works

From organization settings, an owner or admin sends an invitation to a teammate's email address; the teammate accepts it to join with the role chosen for them. Four roles are available: owner, admin, member and viewer, each opening or closing specific settings and actions across the organization. Every project inside the organization follows the same membership, so a new hire sees every project they are meant to the moment they accept. An audit log records every invitation, role change and removal, so it is always clear who changed what and when. An owner can transfer ownership of the whole organization to another member when needed, and a pending invitation can be cancelled before it is accepted if a role was chosen by mistake.

Where to Find It

Open organization settings from any project and go to Members to invite a teammate or change a role. Available on every plan, including the free trial.

Pricing and plan details are on the LogZuno pricing page. Learn more about LogZuno at logzuno.app.

LogZuno now has a Billing page where you can see your usage against your plan's quota, switch plans, manage payment details, and download invoices.

What You Gain

Instead of wondering how close you are to your plan's limit, you can now see it directly: a usage bar on the Billing page shows how many events and pageviews you have used this period against your plan's quota, and when the current period started. Moving to a bigger or smaller plan is a self-serve switch, with no need to cancel and resubscribe, and every past invoice is one click away.

Fair warning before you are cut off

Running out of room used to be a surprise. Now an email goes out automatically when your usage crosses 80%, 90% and 100% of your plan's quota for the period, so you know a limit is close well before new events stop being accepted. If usage does reach 100%, new events and pageviews are held until either the next billing period starts or you upgrade to a bigger plan.

How It Works

Each organization carries its own plan, billing period and usage counter, so moving between organizations shows each one's own standing. Starting or changing a plan opens a secure checkout where promo codes and tax details are accepted, and swapping to another paid plan takes effect immediately rather than waiting for the next renewal. From the same page, a link opens a secure billing portal to update your card, see billing history, and download any invoice as a PDF.

Where to Find It

Open Billing from your organization's settings. Only an owner or admin can change the plan or payment method, the same roles you already set for your team; anyone on the organization can view current usage. See current plans on the LogZuno pricing page.

A project's timezone can now be changed from its settings instead of staying fixed at whatever was chosen when the project was created.

What You Gain

Picking the wrong timezone when setting up a project used to be permanent — every "day" in your charts kept starting at midnight in that timezone forever, even after you noticed the mistake or opened a project for a team in a different region. Now changing a project's timezone is a normal settings change, and LogZuno takes care of the hard part: every day of your event history is recalculated so daily charts, active-user counts and reports line up with the new timezone, not a mix of old and new.

How It Works

Updating the timezone on a project's General settings page queues a rebuild that locks the project briefly, recomputes every daily total straight from the original event data in the new timezone, and releases the lock when it is done; any events still arriving during that short window are held until the rebuild finishes, so nothing is double-counted or lost. The change applies to the whole project's history at once, not just new data going forward.

Where to Find It

Open a project's Settings → General page and choose a new timezone from the dropdown. Only an owner or admin can make the change; members and viewers can still see the project's current timezone.

Learn more about LogZuno at logzuno.app.

Summary

Because agents often work on several tasks side by side, two tasks can end up touching the same part of a project, and whichever merges first can leave the other in conflict. Effigate Command Center now detects that automatically and sends the affected task's own agent to resolve it, instead of leaving it sitting unnoticed.

What You Gain

Before, if two tasks changed the same files and one merged ahead of the other, the second task's proposed change would conflict, and nothing acted on that by itself. It sat there until a person noticed and manually asked the agent to sort it out, which could mean finished work stalling for hours.

Now, every time a change merges, Effigate Command Center checks whether any pending task would still merge cleanly. If a real conflict is found, the task's own agent is automatically asked to bring in the latest version, resolve it while keeping both sets of changes, re-test, and push the fix. The task tells you this happened, and the fix goes through review and merging as usual. If the agent can't resolve it after a couple of tries, it's raised to you as a merge conflict needing a decision.

How It Works

• Automatic detection, fixed by the right agent. Each time a task's change merges, every other pending task is checked for a real conflict; the agent responsible for the affected task brings in the latest changes, resolves it so both pieces of work are kept, re-tests, and pushes the fix.
• Limited, safe retries. A conflict gets up to two automatic resolution attempts. If it still can't be resolved, it's escalated to Decisions with the detail you need to step in.
• Agents are now aware of each other's work. When a run starts, the agent can see which other tasks in the project are still open, so it's less likely to touch work from a task running alongside it.

Where to Find It

This runs automatically for every project with no setup required. If you ever see a merge conflict land in Decisions, it means an agent already tried and couldn't resolve it on its own — everything else is handled silently in the background.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to see your agents work in parallel.

Summary

In the Brick Office view, agents used to line up at your desk only when they had a question for you. Now they also queue there when a run has failed and needs your attention, or when a pull request has a merge conflict an agent couldn't resolve on its own — the same items that already appear in your Decisions list, with questions still shown first.

What You Gain

Before, the Brick Office only reflected one kind of thing waiting on you: an open question. If an agent's run had actually failed and needed a human decision, or if it had hit a merge conflict it couldn't fix itself, that work was easy to miss in the visual office view, even though it was already sitting in your Decisions list.

Now the office view matches your Decisions list completely. Every agent waiting on you, a question, an escalated failure, or an unresolved conflict, lines up at your desk, with a simple marker showing which kind of attention it needs. A quick glance at the office now tells you everything that's waiting on you, rather than checking the office for questions and a separate list for the rest.

How It Works

• Three reasons to queue, one line. Agents now line up at your desk for open questions, escalated run failures, and unresolved merge conflicts — everything that already shows in Decisions.
• A clear marker for each. A question mark shows an agent waiting on a question; a different marker shows one waiting because of a failure or conflict, so you can tell at a glance what kind of attention each one needs.
• One click takes you there. Each agent's card, and your inbox, tell you which kind of item it's waiting on and open it directly in Effigate Command Center.
• Works everywhere you check in. The same labeling is available on older desktop and mobile apps too, so your team sees consistent information regardless of which device they're using.

Where to Find It

This is already live in the Brick Office for every project with agents running — there's nothing to turn on. Open the Office tab to see who's waiting at your desk and why.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to see your own Brick Office.

Summary

Watching an agent work in Effigate Command Center is now more reliable. A run that gets retried, after a machine briefly goes offline, or a pause and resume, now keeps its entire transcript instead of losing most of it. Long-running steps show a live "still working" status instead of going quiet, and every run now uses the current version of the agent's tools rather than whatever happens to be installed on a machine.

What You Gain

Previously, when a run had to be retried, its new attempt restarted its own step counter, so steps overlapping with the first attempt were thrown away as duplicates — sometimes leaving only a single line from several minutes of genuine work.

On top of that, a step that simply took a long time, such as running a big test suite, gave no sign of life for up to ten minutes, making a healthy run look stuck or dead. And on some machines, an older, locally installed version of the agent's command-line tools could quietly be used instead, leading to confusing, unrelated failures.

All three are now fixed: retried runs keep their history, long steps report progress every minute, and every run uses the right tool version.

How It Works

• Retries continue the transcript instead of restarting it. A run that resumes after an interruption picks up its step numbering where the previous attempt left off, so no real work gets discarded as a "duplicate."
• Long steps check in regularly. While a step is still running, the transcript reports "still working" roughly once a minute, so a slow step never looks the same as a stuck one.
• Status updates stay out of your way. The regular check-ins are excluded when diagnosing a failed run, so they never crowd out the steps that matter.
• Every run uses the right tool version. If a machine's command-line tools are older than the ones the desktop app ships with, the run uses the newer, bundled version instead and notes that it did.

Where to Find It

These improvements apply automatically to every agent run on every machine, with nothing to turn on. You'll notice complete, readable transcripts after a retry, and regular progress updates during long steps.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to watch your own agents work.

Summary

Effigate Command Center now keeps an agent run's status consistent everywhere it's shown, on the task, the server, and the desktop app, even when a laptop closes its lid, a machine briefly loses connection, an update restarts the app, or a task is deleted mid-run. Runs no longer get stuck showing "in progress" when they've stopped, or lost when they shouldn't be.

What You Gain

Before this update, a handful of situations could leave a run's status out of sync with reality. Closing or restarting the desktop app for an update could strand a run mid-task, marked "running" indefinitely. A machine that slept or briefly lost connection could fail queued work within minutes, even after it came back. And stopping a run by hand could leave its task showing "In Progress" with no run behind it.

Now every one of those situations resolves correctly. A closing app reports in-flight runs as interrupted and requeues them automatically, instead of failing later with a confusing error. A machine that briefly drops offline gets a fair grace period, with a note on the task about which machine it's waiting for. And stopping a run by hand now correctly returns its task to the right state.

How It Works

• Closing or restarting the app no longer strands runs. In-flight runs are reported as interrupted and automatically requeued, and the desktop app and server now agree on when a run has truly ended.
• Long project setups are no longer mistaken for a stalled run. A run reports it's genuinely working while its project is prepared, so it isn't timed out early.
• A machine going offline briefly, such as a laptop closing its lid, no longer costs you queued work. The task shows which machine it's waiting for, with a fair window to come back.
• Stopping a run by hand, or deleting its task, now updates things correctly — returning the task to the right status and stopping any run still working on it.

Where to Find It

These fixes apply automatically to every agent run, with nothing to configure. You'll notice more accurate statuses on the Tasks tab, the Board, and the desktop app, especially after an update or brief outage.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to run agents on your own projects.

Summary

Three everyday rough edges in how you work with agents are fixed: a question an agent asks now always reaches your Decisions list, a file you attach to a comment now works just as well as one attached to the task itself, and asking an agent about work it already finished no longer accidentally reopens that task.

What You Gain

Previously, if an agent needed a decision from you, its question didn't always reach the Decisions list — sometimes it sat only in a comment that could go unnoticed. Files attached to a comment, rather than the task directly, were sometimes impossible to find or download later, so agents would ask you to attach the same file again at the task level. And simply asking an agent a quick question about finished work could unexpectedly reopen it, moving it backward out of Done or In Review.

Now all three work as expected. Every question an agent asks shows up reliably in Decisions, sent to the right people. Any file attached in a task's comment thread is just as easy to find and download as one on the task itself. And a quick question about finished work gets a quick answer, without reopening or restarting anything unless there's genuinely new work to submit.

How It Works

• Questions always reach Decisions. When an agent needs a decision, its question is sent to the task's assignee, managers, and owner, the same way any other decision item is.
• Every file on a comment is tracked and downloadable, listed alongside task files, so nothing attached mid-conversation gets lost.
• Asking about finished work gets a reply, not a restart. Mentioning an agent on a task that's Done or In Review starts a short reply; the task only moves if the agent is actually submitting new work.
• Consistent behavior across the team. Questions and comment attachments are handled the same way, regardless of which app version an agent runs.

Where to Find It

All three fixes are live automatically for every project, with nothing to turn on. Agent questions reach Decisions as before, comment attachments download reliably, and finished tasks stay finished unless an agent has real new work to show.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to work alongside your own agents.

Summary

Every task's priority now looks the same everywhere you work in Effigate Command Center — on board and sprint cards, in lists, filters, and quick pickers, inside AI-assisted task creation, and on the dashboard. Priority appears as a simple bar chip: one bar for Low, two for Medium, three for High. Critical tasks get three bars in red, so the work that needs attention first is impossible to miss, in light or dark mode.

What You Gain

Before this update, a task's priority was shown differently depending on where you looked — a word, a color, or nothing obvious at all. Scanning a busy board or a long sprint list for the tasks that actually needed urgent attention meant reading every label carefully, easy to miss when moving fast.

Now priority reads at a glance, everywhere. A manager scanning the dashboard can spot a Critical task's three red bars from across the room, and someone picking their next task from a filtered list sees instantly which items outrank the rest. Because the same system appears in task creation and AI-assisted proposals too, priority is consistent from creation to close, with no more guessing whether "High" in one place matches "High" elsewhere.

How It Works

• A consistent bar chip everywhere. Low priority shows one grey bar, Medium shows two, and High shows three, on board cards, sprint cards, project and sprint lists, the task window, and every filter or picker.
• Critical stands out on purpose. A Critical task shows three bars in red instead of grey, reading differently from High rather than blending in as one more full bar.
• Shows up where you create and assign tasks too. When you, or an AI-assisted proposal, set a task's priority, the same chip is used immediately, so what you choose is what you'll see later.
• Matches in dark mode. The bars and colors were tuned separately for dark mode, so Critical is unmistakable at night as well as during the day.

Where to Find It

This is already live for every task in every project — there's nothing to turn on. You'll see the new priority bars anywhere a task's priority appears: boards, sprint and project lists, filters, pickers, and the dashboard.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

When an agent working in Chat with Agents needs a decision from you, it no longer buries the question inside a wall of text. It now asks through a dedicated question card: one clear question at a time, with ready-made answer options and the agent's own recommendation already highlighted, so you can respond with a single click instead of typing a reply.

What You Gain

Previously, when an agent had more than one open question, all of them arrived together in a single chat reply, and had to figure out which answer belonged to which question, then type one response covering everything — easy to miss a question, or answer one while skipping another.

Now each question appears in its own card, one at a time, with controls to move between them. Every option tells you what choosing it means, and the agent's recommended answer is already selected, so agreeing takes one click, and overriding it is just as easy. If none of the options fit, write your own answer, or skip and return later. One click then sends every answer back to the agent at once.

How It Works

• One question, one card. Cards show a single question with a counter, like "1 of 3," so you always know how many are left.
• Options explain themselves. Each choice spells out what picking it means for the task, with the agent's recommended answer pre-selected.
• Write your own answer, or skip. An "Other" option lets you type a free-form reply when none of the suggestions fit, and "Skip" moves past a question.
• Submit sends everything together. Pressing submit sends all your answers back to the agent as a single message, with full context at once.
• Works everywhere you chat with agents. The same card appears in the mobile app; in Slack, questions appear as a numbered list so nothing is missed there either.

Where to Find It

Question cards appear automatically inside any Chat with Agents conversation, on web and mobile, whenever an agent needs your input — there's nothing to turn on. If you'd rather just type your answer directly into the chat, that still works; the card simply closes once you reply.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to see how your team chats with agents.

Summary

Uploading a file that wasn't allowed — the wrong type, or too large — used to do nothing at all, with no message explaining why. Every upload across the app now tells you immediately when a file won't work, and why, before you lose any other work in progress.

What You Gain

A failed upload with no explanation leaves you guessing whether the app is broken or the file is the problem. Now you're told right away, the moment you pick a file, if its type isn't supported or it's too big — and if the server itself refuses it, you see that reason too. An expense receipt that can't be attached also no longer leaves behind a half-saved, incomplete expense entry.

How It Works

Covers uploads across the app, including:

• Employee photos, documents and signed contracts
• Expense receipts and invoice payment proofs
• Agent and profile photos
• Skill files
• Chat with Agents attachments

Where to Find It

Already live everywhere uploads happen, for every workspace.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Until now, only agent runs on your own computers recorded what they cost. The AI Assistant panel, AI Chat, voice notes, and the background AI work Effigate does on its own — like diagnosing a failed run or summarizing a chat — recorded nothing. Every one of those now records its tokens and cost, attributed to the project, person and conversation it came from.

What You Gain

Understanding your actual AI spend used to mean looking only at agent runs and guessing at everything else. A busy team using the AI Assistant, AI Chat and voice notes throughout the day had real costs accumulating that simply weren't visible anywhere.

Now every one of those is recorded against the project, person and conversation it belongs to, and it feeds directly into the coming delivery report alongside agent run costs. Picture reviewing a project's AI spend at the end of the month: instead of seeing only what agents cost, you see the full picture — assistant conversations, chat usage, voice notes and background AI work, all in one place, with nothing missing and nothing silently counted as free.

How It Works

• Full coverage. Every AI interaction — AI Assistant, AI Chat, voice notes, and background AI work — now records its cost.
• Honest pricing. Cost comes from a table of current model prices; a model that isn't in the table is marked unpriced, never shown as free.
• No lost steps. An AI Assistant answer that looked something up used to lose the cost of the look-up step; every step is now counted.
• Desktop agent runs report their model. Runs now say which AI model they used, so cost can be worked out even for tools that didn't previously report it; tools that report neither model nor cost are marked cost not reported, not $0.

Where to Find It

Live now across the web app; accurate desktop agent run costs need the current desktop app or command-line tool.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Deleting a task from the sprints view, the mobile app or the command-line tool used to skip the Delete tasks permission check that the main task page already enforced. That gap is closed: every way of deleting a task now respects the same permission, and an agent can never delete a task on your behalf.

What You Gain

Picture a workspace where only team leads are meant to delete tasks. Before this fix, that rule only held on the task's own page — a teammate using the sprints board, the mobile app, or the command line could delete a task they were never meant to touch, and an agent working unattended could do the same. Now the rule holds everywhere, consistently, the way it was always meant to.

Deleting a task you are allowed to delete also now behaves more completely: it immediately stops any of that task's unfinished agent runs and removes it from everyone's open boards, exactly as deleting from the task page always did.

How It Works

• One consistent permission, checked everywhere. The sprints view, mobile app, command-line tool and task page all require the same Delete tasks permission.
• Agents can never delete tasks, even when the person whose computer is running them has permission to.
• The Delete button is hidden from anyone without the permission, in the sprints view and the mobile app, matching the task page.
• Clear messaging. If a delete is refused, you're told why.

Where to Find It

Live now for the web and command-line tool; the mobile app change needs the current app version. No setup is needed — your existing roles and permissions apply automatically.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Attaching a file to a task or comment could silently fail — the comment posted, but the file never appeared, with no explanation. SVG files were the most common case. Tasks, comments and the AI Assistant now accept SVG files, and any file that can't be attached tells you exactly why.

What You Gain

A silent failure is the hardest kind to deal with, because there's nothing telling you what went wrong or what to try instead. Now, the moment you pick a file that's too large or an unsupported type, you're told immediately, before you've even finished writing your comment. Pickers also only offer files that will actually work, so there's less guessing in the first place.

How It Works

• SVG files now attach cleanly to tasks, comments and the AI Assistant, downloaded rather than previewed inline.
• Clear, immediate errors when a file's type isn't supported or it's over the 20 MB limit.
• Smarter file pickers that only offer files that can actually be attached.
• AI Chat stays focused on screenshots — JPG, PNG, GIF and WEBP only — and now says so clearly if you pick anything else, instead of dropping the upload silently.

Where to Find It

Already live across the web app for every workspace.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

An agent's Recent work section used to show only its newest 10 runs, with no way to see the rest, and a confusing count that mixed different time periods. It now lists every finished run, paged 20 at a time, each one explained in plain language — whether it completed, failed, or was later fixed by a retry.

What You Gain

Trusting an agent to work independently means being able to check its history when something looks off, but the old Recent work list only ever showed a handful of the most recent runs, with a count that didn't actually describe what you were looking at. If you wanted to know how an agent had been performing over the last month, there was no reliable way to see it.

Now every finished run is listed, filterable by Work, Review, Rework or Chat, with stopped runs and chat turns included. Each row tells its own story in words: whether the run completed, failed, or was stopped; where the task it worked on stands right now; the plain reason a failed run failed; and whether a later run on the same task succeeded, and by which agent. A handful of past runs that were wrongly recorded as having left work unfinished, even though their pull request had actually merged, have also been corrected and clearly marked, while runs that genuinely failed are left exactly as they were.

How It Works

• Every run, not just the newest ones. Paged 20 at a time, with a count that matches what's shown.
• Filter by kind. Work, Review, Rework or Chat, including stopped runs.
• Plain-language status. Each row says whether the run completed, failed, or was stopped, and why.
• Task context included. Each row also shows where the task itself currently stands.
• Retry awareness. A row tells you if a later run fixed the same task, and whether it was an automatic retry.
• Chat visibility respected. A chat turn only shows its title to people who could already open that chat.

Where to Find It

Available now on every agent's page for every workspace — no setup required.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own agents.

Summary

Filters, forms, the task window, the AI Assistant panel and reports all used the browser's own default dropdown style, which varied and didn't scale well for long lists. They now share one consistent dropdown, and any list of more than five options gets a built-in search box.

What You Gain

Picking a project, agent, person or timezone from a long list used to mean scrolling through every option in order, hunting for the one you wanted. Now you just start typing and the list narrows to match, which makes a large workspace with many projects and people noticeably faster to work in day to day.

How It Works

• One look everywhere. Filters, forms, the task window, the AI Assistant panel and reports all use the same dropdown now.
• Search on longer lists. Any list with more than five choices includes a search box.
• Opens correctly everywhere. Dropdowns inside dialogs and the task window now open above them instead of underneath.
• Required fields still protected. A form still can't be submitted until a required dropdown has a choice.

Where to Find It

Already live across the entire web app — no setup required.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Effigate Command Center now has a dedicated Delivery Report under Insights, showing exactly what was delivered over a month, or a custom range of up to three months, for your whole company or for one team, project or agent — paired with what it cost to deliver.

What You Gain

Before this, answering "what did we actually ship last month, and what did it cost us" meant piecing the answer together from several different screens, or not being able to answer it precisely at all. Teams running agents alongside people had no single place to see delivered work and its real cost side by side.

Now one report answers both questions at once. Picture a manager checking a project at month's end: they see every task delivered, whether it was finished by a pull request merging on GitHub or moved to Done directly, who delivered it, and the full cost behind it — agent runs, reviews, and any AI used along the way. Work is counted once, on the day it was truly finished, even if a task was reopened and completed again later.

How It Works

• Delivered work, clearly defined. A task counts once, on the day it last reached Done; sub-tasks count as their own delivered work.
• By agent. Each delivered task is split into credit across its author, reviewer and any helpers, so you can see each agent's share of the work, success rate, and reworks.
• Full cost picture. Spend covers agent runs and the app's own AI use — AI Chat, the AI Assistant, background AI and voice transcription — broken down by source, with anything not yet priced shown honestly rather than as free.
• Cost per delivered task. Every run behind a task, including reviews and rework, rolls into one cost-per-task figure.
• Flexible views. Filter by company, team, project or agent, and pick any custom range up to three months.

Where to Find It

Open the Delivery Report from Insights. Managers can open it by default; any other role can be granted the new View delivery report permission.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Effigate Command Center now has a dedicated Activity page, under Work in the sidebar, that turns a day's worth of updates across your tasks into a clear, hour-by-hour timeline — moved out of the dashboard, where it used to be squeezed into a small panel.

What You Gain

A day's worth of activity across a busy team — merges, completions, failures, status changes, feedback — is hard to follow when it's squeezed into a small panel alongside everything else on a dashboard. Giving it a dedicated page, with its own timeline and filters, makes it genuinely usable for actually following what happened, rather than just a glance-and-move-on widget.

Picture starting your morning by stepping back to yesterday afternoon: you see exactly what happened, hour by hour, who did it, and can jump straight from any update to its task, project, sprint, or pull request.

How It Works

• One day at a time. Opens on today; use the arrows to step a day, or the date picker to jump anywhere, following your workspace's timezone.
• A timeline grouped by hour, newest first, with a marker showing what kind of update it was.
• Direct links from every update to its task, project, sprint and pull request.
• Filters for one project, or one person or agent.
• Respects what you can see. You see activity only on tasks you're already allowed to see, same as the Board.

Where to Find It

Open Activity under Work in the sidebar, available now for every workspace.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The Effigate Command Center mobile app now shows a short notice under AI Chat and Chat with Agents explaining that workspace admins granted the right permission can read the conversation — matching the notice already shown on the web.

What You Gain

Transparency about who can see a conversation shouldn't depend on which device you're using. Workspaces where a chosen admin can read every team member's conversations for oversight already disclosed that plainly on the web, right under the message box, but the phone app stayed silent about it, leaving a gap in what people on mobile were told. With this update, anyone chatting from their phone sees the same plain notice as someone on the web, so there's no gap between platforms in what people are told about their conversations.

How It Works

• The same notice, on mobile. AI Chat and Chat with Agents in the phone app now show "Your workspace admins can read this chat" under the message box, exactly as the web app already does.
• No setting to turn on. The notice appears automatically wherever the underlying admin-visibility permission applies to your workspace; there's nothing to configure on the phone.
• Matches the web app's wording. The phone app reuses the same plain language as the web, so the disclosure reads identically on either device.

Where to Find It

Arrives with the next mobile app update; no action is needed once you've updated.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center on your phone.

Summary

Dropdowns opened from inside the AI Assistant panel or the task window, such as a project picker, were appearing behind the panel instead of on top of it, making them unusable. Dialogs, menus, popovers and side sheets now consistently layer above these panels.

What You Gain

A dropdown that opens invisibly behind the very panel you're using is effectively broken — you click it, nothing visible happens, and you're left wondering if the app is frozen. The project picker inside the AI Assistant panel was a clear example: its list of projects rendered underneath the panel instead of over it, so there was nothing to choose from. The same layering problem showed up in dropdowns opened from the task window. This fix removes that frustration everywhere it showed up, so every menu and dropdown now opens exactly where you'd expect, on top of whatever panel you're working in.

How It Works

• Dropdowns render above panels, not behind them. Lists opened from the AI Assistant panel, such as its project picker, and from the task window now appear over the panel instead of underneath it.
• The same fix covers dialogs, menus, popovers and side sheets. Anything that opens on top of a panel now does so consistently, including above sticky headers.
• No change to the choices themselves. Only where these elements appear on screen changed; what you can pick from each list is the same as before.

Where to Find It

Already live for everyone — no setup required.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Sensitive files such as employee documents, signed contracts, expense receipts and payment proofs are now stored privately and open only to people allowed to see them, closing a gap where simply knowing a file's link was enough to open it without signing in.

What You Gain

Documents like signed contracts or payment proofs are exactly the kind of files a company needs to control carefully — who can see them should depend on their role, not on whether they happen to have a link. Picture an HR document or an expense receipt: it should be visible to HR, or to whoever approves expenses, and to no one else by default. That's now exactly how it works.

How It Works

• Private by default. Employee documents, contracts, receipts and payment proofs are stored where only permitted people can open them.
• Permission-based access. HR sees employee files, people who can see expenses see receipts, and people who can see payments see payment proofs.
• Existing files were moved to the new, private storage automatically.
• Old links no longer work — anyone needing a file now opens it through the app, where access is checked properly.

Where to Find It

Already in effect for every workspace — no action needed from you.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Getting the Effigate Command Center Android app is now a single link from inside your own workspace, always pointing at the latest published version — no separate app-store search required.

What You Gain

Rolling out a mobile app across a team is usually only as easy as the slowest person to find and install it. A direct download link from your own workspace removes that friction: share one link, and everyone lands on the same, current version of the app.

How It Works

• One link, always current. The download page always serves the latest published version of the Android app.
• Straightforward install. Open the link on an Android phone and allow installing apps from your browser if prompted.

Where to Find It

Available now from your workspace's mobile app download page. The first version published there is 1.0.4.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center on your phone.

Summary

The Dashboard now opens on a new Operational tab by default. Revenue, invoices, expenses and other financial figures moved to a separate Finance tab that only people with a new permission can see, rather than everyone who can open the dashboard at all. Several counts and links across the dashboard were also corrected.

What You Gain

Financial figures like revenue, payroll and bank balances are sensitive by nature, but before this change, anyone who could open the dashboard at all could see them. A small team might not mind that, but a growing one usually wants finance visible only to the people who need it — managers, admins and the roles they choose.

Picture a company where only finance leads should see revenue and payroll, while the rest of the team should see delivery and workload numbers. Now that's exactly how it works out of the box: everyone opens the dashboard on an operational view, and financial figures are a separate tab visible only with the new View finance dashboard permission. On top of that, several numbers that were previously counting the wrong things — overdue counts including finished tasks, backlog counts mislabeled as "unclaimed," sprint deadlines missing active sprints — now report correctly, and two links that used to lead nowhere now open the right filtered view.

How It Works

• Operational tab by default. Everyone who can open the dashboard starts here.
• Finance tab, permission-gated. Revenue, invoices, expenses, bank balances, payroll, advances and loans require the new View finance dashboard permission — granted to managers, admins and Super Admins by default.
• Corrected counts. Priority & Type, Task Pipeline, Overdue, Active Projects and Sprint Deadlines now count the right tasks, including a new Critical row and fixed handling of cancelled and backlog work.
• Working links. "View all overdue tasks" and the backlog link now open the Board filtered to exactly those tasks, with a chip to clear the filter.
• Honest empty states. A Finance panel with nothing to show says "No data yet" instead of displaying a misleading zero.

Where to Find It

Live now for every workspace. Grant View finance dashboard to any role beyond the defaults from your Roles settings.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The Operational tab of the dashboard has grown into a real month-by-month answer to the questions an owner or manager actually asks: what did we deliver, what's stuck and waiting on someone, and how is each project, agent and person doing. It replaces the old Team Performance table, which only ever told part of the story.

What You Gain

Before, understanding how a month actually went meant jumping between several screens, or relying on a performance table that only counted people with a specific role — leaving out the agents doing most of the day-to-day work. For a team that runs largely on agents working alongside a smaller group of people, that left a real blind spot.

Now the dashboard pulls it together in one place. Picture checking in at month's end: you see tasks delivered compared with last month, a chart of the trend, what's been stuck and why, and whose turn it is to unstick it. Each project shows a clear health read — blocked, at risk, or on track — explained by the actual work behind it, not a vague score. Agents show their share of delivered work, success rate and cost, right alongside the people on the team.

How It Works

• Delivered, compared to last month. With a daily or weekly trend chart, plus spend and cost-per-task for anyone who can see the Delivery Report.
• Waiting on people, and what needs attention. The same stuck-work signals as the morning digest email, oldest first, with a direct link to your own Decisions queue.
• Project health, explained. Blocked (a task is stuck), at risk (no delivery in 7 days, or a sprint past its deadline), or on track — always with the reason shown.
• Agents and people, side by side. Credit, first-time-right rate, reworks and cost for agents; what each person created, what's waiting on them, and when they were last active.
• One click to the work. Backlog, Unassigned and Overdue each open the Board filtered to exactly those tasks.

Where to Find It

Available now on the Operational tab for every workspace, following your own timezone for days and months.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Costs that couldn't be measured used to show as $0.00 on the dashboard and Delivery Report, which looked like free work rather than missing data. They now say "Not reported," or a floor value like "$4.20+" when part of the cost is known. Recent Activity and the People list were also cleaned up.

What You Gain

A cost shown as zero reads as "this was free," which isn't the same thing as "we couldn't measure this." That distinction matters when you're using these numbers to understand what a project or agent actually costs — a silent $0.00 could quietly understate real spend. Now the dashboard is upfront about what it does and doesn't know, so the numbers you see can be trusted at face value.

How It Works

• Honest cost reporting. Costs that weren't reported show "Not reported"; a partially known cost shows as a floor, like "$4.20+", on both the dashboard and the Delivery Report.
• Cleaner activity. Recent Activity no longer repeats a task's title and project twice in the same entry.
• Relevant people only. The People list on the dashboard leaves out accounts that have never done anything.

Where to Find It

Live now across the dashboard and Delivery Report for every workspace.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Deleting a checklist item from inside the task window used to open its confirmation dialog behind the window itself, leaving nothing clickable. Confirmations, menus, tooltips and popovers opened from the task window or a side panel now consistently appear on top.

What You Gain

A confirmation you can't see or click is worse than no confirmation at all — it just looks like the app has stopped responding. Deleting a checklist item was the clearest example: the confirmation dialog opened directly behind the task window, so there was nothing to click and no way to tell whether the delete had gone through or the app had simply frozen. This fix removes that dead end everywhere it occurred around the task window and side panels, so every confirmation, menu, tooltip and popover now opens where you can actually see and interact with it.

How It Works

• Confirmations come to the front. A delete confirmation opened from the task window, such as removing a checklist item, now always renders above the window instead of behind it.
• Menus, tooltips and popovers follow the same rule. Anything opened from the task window or a side panel now layers on top of it, not underneath.
• No change to what you confirm. The fix only affects where these elements appear on screen; the actions themselves, and what they do, are unchanged.

Where to Find It

Already live for everyone — no setup required.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

If the computer running an agent went to sleep while it was answering a chat message, that message could get permanently stuck on "Waiting," blocking every message sent afterward until the desktop app was restarted. A stuck or stopped message now always resolves, so the conversation keeps moving.

What You Gain

A chat that silently stops responding is confusing and, until this fix, had no clear fix besides restarting the app. Now a message that can't finish because its computer went to sleep is handled cleanly: the time spent asleep doesn't count as the agent being idle, the message is never run twice, and the next message starts right away instead of queuing behind a stuck one. The desktop app also now correctly shows a message as running while it's in progress.

Where to Find It

Requires the current desktop app.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own agents.

Summary

AI Chat now checks that a screenshot or voice note being read actually belongs to the person sending the message, closing a gap that previously let a conversation reference a file it shouldn't have had access to.

What You Gain

Trusting a shared AI tool means trusting that it only ever looks at your own files, not anyone else's. Before this fix, AI Chat would read whichever screenshot or voice note it was pointed at, without checking who had actually uploaded it — so, in principle, a conversation could end up referencing a file that belonged to someone else entirely. This tightens that boundary: AI Chat now strictly uses only the files uploaded by the person sending the message in that conversation, so everyone's screenshots and voice notes stay theirs alone, with no quiet overlap between people's chats.

How It Works

• Checked at the message level. Every time AI Chat is asked to read a screenshot or voice note, it now confirms the file was uploaded by the person who sent that message, in that conversation.
• No cross-conversation access. A file one person attaches can no longer be pulled into an answer for someone else's message, even inside the same shared workspace.
• Applies to every file type AI Chat reads. The same ownership check protects screenshots and voice notes alike, with no separate setting to configure.

Where to Find It

Already live for every workspace — no setup required.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

When an agent created a task and included a checklist, those items used to be written as plain checkbox-style text inside the task description, not as the task's actual checklist — the one the assigned agent actually works through. They now become real checklist items, in order, with their section heading kept as a label.

What You Gain

A checklist that only looks like a checklist, sitting as text in a description, doesn't function like one — it can't be checked off, tracked, or relied on by whoever (or whatever) works the task next. Now when an agent creates a task with a checklist in mind, it's immediately usable the way a checklist should be: trackable, tied to the task, and visible wherever checklists appear. Tasks that people create and write by hand are left exactly as written.

Where to Find It

Live now for every workspace; agents can also add checklist items directly using the current desktop app or command-line tool.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own agents.

Summary

Effigate Command Center now has a permission, View everyone's chats, that lets the people you choose read every team member's AI Chat, AI Assistant and Chat with Agents conversations in one place. It's for oversight — checking how AI is being used across a team — not daily reading, and it's read-only.

What You Gain

Teams adopting AI chat and agents at scale often need a way to review how it's being used — to spot good practices worth sharing, or catch a conversation that's gone off track — without asking each person to forward their own chats. Before, that kind of oversight simply wasn't possible: every admin could see only their own conversations.

Now a Super Admin, or anyone granted the new permission, can open a single screen that pulls together every person's chats, filterable by person, where the chat happened, project, agent, and date. Picture a team lead doing a monthly check on how well the AI Assistant is helping their team: instead of asking everyone individually, they open one screen and see it all, read-only, with full transparency to the team about who can see what.

How It Works

• One permission, clearly granted. Super Admins have it by default; any other role only gets it if you grant it on the Roles screen.
• One place to look. Open AI Chat and switch to Everyone's chats to see every conversation across the workspace.
• Useful filters. Narrow by person, where the chat happened, project, agent, and date range.
• Read-only, always. Reviewers can read but never reply, change, or mark a chat as read.
• Fully disclosed. Every chat now tells the person using it, right under the message box, that workspace admins can read it, and the help guides explain the same.

Where to Find It

Already live for every workspace. Super Admins have the permission by default; grant View everyone's chats to any other role from the Roles screen to extend it.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The Linked chats section in a task's sidebar used to stretch past the edge of the panel whenever a chat had a long title, adding an awkward horizontal scrollbar. It now lines up with every other section in the sidebar, and long titles are shortened neatly instead.

What You Gain

A task with a chat that had a descriptive, longer title could throw off the whole right-hand sidebar, forcing it to scroll sideways just to show that one line — a rough edge on a panel you look at constantly while working a task. Linked chats now behaves like every other section around it: full width, clean, and legible no matter how long the chat's title is.

Where to Find It

Already live for everyone — no setup required.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Computers running Effigate's standalone command-line tool, rather than the desktop app, can now be updated remotely with a single request. The update downloads safely in the background and is put in place automatically the next time that computer isn't running a task.

What You Gain

Teams that run agents from the standalone command-line tool, on a server or a machine without the desktop app installed, previously had no reliable way to update it from a distance — remote update requests had quietly stopped working for current installs, so keeping every machine current meant visiting each one by hand. For a team with several machines running agents around the clock, that's a real maintenance burden.

Now a remote update request downloads the correct version, verifies it against a published checksum, and keeps it ready while the current version keeps working. The moment that computer finishes its current task and has nothing running, it swaps in the new version automatically; if the swap can't complete, it simply keeps running the version it already has, so nothing breaks. A machine that's already current says so and doesn't restart for no reason.

How It Works

• One request updates any standalone machine. No need to be at the keyboard of the machine itself.
• Safe by design. The new version is checked against a published checksum before anything changes, and the swap only happens when the machine is idle.
• Falls back safely. If an update can't be installed, the machine keeps running on its current version rather than breaking.
• Desktop app machines are unaffected — they already update themselves, and now say so plainly if asked to update this way by mistake.

Where to Find It

Each machine needs this version installed once by hand, by re-running the installer; after that, updates can be requested remotely from anywhere.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own fleet of agents.

Summary

The AI Assistant panel now accepts file attachments — screenshots, PDFs, documents, spreadsheets, text files and archives — right alongside your message, and those files automatically travel with any tasks you later confirm from that conversation.

What You Gain

Explaining a problem to the AI Assistant in words alone is often slower and less precise than just showing it: a screenshot of an error, a spreadsheet of numbers, a document with requirements. Before, there was no way to hand any of that over — you had to describe it instead, or create a task first and attach the file afterward.

Now you can attach up to 10 files per message, paste a screenshot straight into the box, or drag files onto it, and even send a message that's nothing but files. Picture asking the Assistant to turn a bug screenshot into a task: it sees the image together with your message, and when you confirm the task it proposes — on its own, in a batch, or as a full sprint — the screenshot is already attached to it, with no extra step.

How It Works

• The assistant sees your images. Screenshots go to the AI along with your message, and every attached file is referenced by name so it can be discussed directly.
• Files travel with the work. When you confirm tasks the assistant proposed, every file sent earlier in that conversation is attached to each new task automatically. Files sent after a proposal is made are kept out of it.
• Available everywhere the task is. Attached files show up in the task's Attachments panel, in the mobile app, and in the command-line tool's attachment listing.
• Click to view. Images open in a zoomable viewer; PDFs and text files open in a new tab; other files download directly.
• Private by default. Only the person who had the conversation can open the files sent in it.

Where to Find It

Available now in the AI Assistant panel for every workspace — look for the paperclip next to the message box, no setup required.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Agents using the Effigate command-line tool could read a task's attachments but couldn't add any, so a screenshot or document they produced had to be posted as a comment instead of a proper attachment. That gap is closed: agents can now attach files the moment they create a task, or add them to one that already exists.

What You Gain

An agent that finishes an investigation with a screenshot, a log file, or a generated document previously had no clean way to hand it over — the file ended up buried in a comment thread instead of sitting with the task where you'd expect to find it. Now that file lands exactly where a person uploading it from the web app would put it: in the task's own Attachments panel, easy to find later.

Picture an agent that creates a task to report a visual issue it found: it can now create that task with the screenshot attached in the same step, instead of writing a comment that says "see the image below." The same applies to adding files to a task that's already open.

How It Works

• Attach while creating a task. Repeat the attach option to add more than one file in the same step.
• Attach to an existing task. Add one or more files to any task you can already see.
• Shows up everywhere. Attached files appear in the task's Attachments panel and in the command-line tool's own attachment listing, alongside anything uploaded from the web app.
• Same limits as the web app. Supported file types and the 20MB-per-file size limit are unchanged.
• Checked before anything is created. Every file is validated before the task is created, so a typo in a file path can't leave behind a task with missing attachments. If an upload fails partway through, you're told the task was already created and given the exact next step to attach what's left.

Where to Find It

Requires the current version of the Effigate desktop app or command-line tool. Available to every agent and workspace once updated.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own agents.

Summary

Opening a file attached to a task in the mobile app used to fail with a loading error. Attachments now open reliably on your phone, the same way they already did on the web.

What You Gain

If you attached a screenshot, PDF, video or document to a task on the web and then tried to open it from your phone, you'd see "Couldn't load this image" instead of the file. That made the mobile app unreliable for anyone who needed to check an attachment away from their desk. Attachments now open the same way on both, so you can review a screenshot or document from your phone exactly as you would at your desk.

Where to Find It

Already live for everyone using the Effigate Command Center mobile app — no setup required.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center on your phone and desktop.

Summary

Some agent runs that had already committed their work and opened a pull request were being marked as having left work unfinished, triggering a "needs your input" notification even though review was already under way. That false alarm is fixed.

What You Gain

Before this fix, a run could do everything right — finish its work, commit it, and hand the task to review — and still get flagged afterward with an unfinished-work warning, sending you a notification that something needed your attention when nothing actually did. For a team relying on agents to work independently, a steady trickle of false alarms makes it harder to trust the real ones.

The cause turned out to be harmless leftover files that some project setup steps, or local tools, create on their own and were never part of the agent's actual work. Effigate Command Center now recognizes those harmless leftovers and no longer treats them as a sign the agent left something uncommitted. A run that genuinely leaves real, unexpected changes behind still fails the check exactly as before — this only removes the false positives.

Where to Find It

This fix needs the current desktop app; update it to stop seeing the false alerts.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own agents.

Summary

Effigate Command Center now lets you share a chat with an entire project instead of just one task. Once shared, everyone on the project is notified, it appears in a new Background chats list, and every agent on the project's tasks can read it for context, keeping the discussion that shaped a project visible to the whole team.

What You Gain

Before, a conversation that shaped a whole project — a planning discussion, a client call, an early research chat — lived inside one chat tied to whichever task you happened to be in. Teammates on other tasks never saw it, and their agents had no way to know it existed, even though it explained why the project was taking the shape it was.

Now you can share any chat to its project in one step. Share a conversation where you worked out an approach, and every current and future task in that project, with its agents, can read it as background, the same way they'd read a task's own description. If the shared background ever disagrees with a task, the agent follows the task.

How It Works

• Share from the chat or the project. Use "Share with a project" from a chat's menu, or "Share one of your chats" from the project. Everyone on the project is notified.
• A dedicated Background chats tab. Each project has its own tab listing every shared chat, with a short summary, visible to anyone who can see the project.
• Agents read it automatically. Any agent working a task in the project, or chatting about the project itself, gets the shared chat's summary and can open it in full.
• Linked chats show the full picture. A task's Linked chats panel lists its own chats first, then the project's shared background, exactly what its agent sees.
• Easy to undo, nothing lost. Only the sharer, or a project manager, can remove it; the chat itself is never deleted.
• Quieter chats. Linking a chat to tasks no longer posts automatic notes into the chat.

Where to Find It

Available now on every project — no setup required. Open any chat's menu to share it, or start from a project's new Background chats tab.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Chat with Agents is easier to live in day to day: you can now search across every chat, including archived ones, see at a glance which ones have a reply you haven't read yet, and see what your AI conversations are costing broken out by project, not just as one combined number.

What You Gain

Finding an old conversation used to mean scrolling and guessing which chat it was in. Now a single search box covers every chat's title, agent, and message content, archived chats included, and shows the exact message that matched, on both web and phone.

Keeping track of what needed a reply was just as manual: nothing told you which chats had moved on. The sidebar's Chat item, and Chats on the phone, now carry an unread badge that updates the moment a reply arrives, so a busy week doesn't quietly bury the ones waiting on you. And because AI conversations have a real cost, those costs now count toward the right project's usage figures, with a separate filter for chats not about any project, so a team's AI spend lines up with the work it paid for.

How It Works

• Search everything. One search box covers chat titles, agents, and message content, archived chats included, on web and mobile.
• Unread badge. The sidebar (and the phone app's Chats tab) shows a count of chats with an unread reply, updating live as replies come in.
• Costs follow the project. Chat costs now appear on each project's Usage page; chats with no project have their own Chats (no project) filter.
• Faster long chats on mobile. The phone app now loads the latest messages first, with Load earlier messages for the rest.
• Fair-use limits. Sending messages, attaching files, and linking or sharing chats are rate-limited per person, with a plain "wait a moment" message if you hit the limit, the same protection that applies to a connected Slack bot.
• Tidier storage. Files attached to a chat but never sent are automatically cleaned up after a day.

Where to Find It

Live now for everyone using Chat with Agents, on web and mobile, with no setup needed. Costs by project appear automatically on each project's Usage page.

See what else shipped this month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Effigate Command Center's Agent Office is now fully live on your phone, built on the same data as the desktop app, so the two always agree on who is working, who is waiting, and what has shipped. See your team's progress, answer a waiting question, or check what landed today, all from your pocket.

What You Gain

Until now, tracking your agents' work on the go meant opening tasks one by one, with no single view of who was doing what, and no way to see which agent needed an answer, which one just shipped, or which run had failed.

Picture stepping away from your desk while three agents are mid-task: one needs a decision, another ships a pull request, a third hits an error. Open the app and you see all three at once — a question waiting, a fresh delivery on your shipped shelf, and a run marked red, all without touching a laptop.

How It Works

• Your office, at a glance. The top of the screen shows your Shipped shelf with today's completed work, a notice board, and anyone waiting at your desk with a question.
• Waiting on you. Each open question appears with a direct "Answer" button that takes you straight to the task.
• Live run progress. For every agent at work, you see the tool it's using and which of its five steps it has reached, updating in real time.
• Shipped and failed runs stand out. A completed run's rocket lands on your shelf and the count ticks up; a failed run turns red so it's easy to spot.
• Sounds, vibration, and widgets. Optional sounds and vibration mark launches, landings, failures, and new questions, each with its own switch. A home-screen widget shows who's waiting and today's ship count; the Lock Screen widget shows the question waiting on you.
• Smarter notifications. A question arrives as a clear push naming the agent, reaching the right people, with a tap opening straight to its task.

Where to Find It

The Agent Office is available now in the phone app for iOS and Android, to anyone who already uses agents in their workspace. No setup is needed; it appears automatically alongside your tasks and agents.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center on your own team.

Summary

Effigate Command Center now lets a chat with an agent travel with the work it leads to. Create a task from a conversation, or link a chat to one that already exists, and the task keeps an updated summary of what was discussed.

What You Gain

Before this, a useful conversation with an agent and the task it became were two separate, disconnected things. If a colleague opened the task later, they had no way to see the back-and-forth that shaped it, the decisions made, or the questions asked and answered along the way.

Now that context travels with the work. Imagine chatting with an agent about the right approach to a tricky project, then turning that conversation into a task once you've landed on a plan. Anyone who opens the task later sees an updated summary of the chat's decisions and open questions, and can read the full conversation for the whole story. The agent working the task sees that same summary and conversation, so it starts from everything already agreed.

How It Works

• Create a task from a chat. Use "Create task from this chat" in a chat's menu, pick the project, write the title and description yourself or have them drafted, and optionally assign it to the agent.
• Link a chat either way. Link an existing task to a chat from either side, by the task's ID in the chat, or under the task's Linked chats section.
• A live summary on the task. The task shows a short, updated summary of the chat's decisions, constraints, and open questions, with the full conversation available to read.
• The agent follows the task when they differ. The agent working a linked task sees the chat's context, but follows the task's own details if the two disagree, and says so.
• One chat, many tasks. A single chat can link to every task that grew out of it, without posting updates back into the chat.
• Access matches the task. Anyone who can see the task can read a linked chat; only its starter can link or unlink it.

Where to Find It

This is available now to everyone using Chat with Agents, on the web app, with no setup needed.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own projects.

Summary

Effigate Command Center's phone app now offers a second way to see your team of agents at work: a full, animated Office view, matching the desktop experience. Switch between a simple list and the living office with one tap, and the app remembers which you prefer.

What You Gain

The phone's earlier Agent Office view told you who was doing what, but only as a list. It couldn't show you the office itself, the sense of a team working, finishing, and moving between desks that makes the desktop version satisfying to glance at during a busy day.

Now that same living office fits in your pocket. Checking your phone between meetings, an agent that just finished has its rocket lift off with a burst of confetti and land on your shelf, while another walks over with a question mark above it. You see the team's day unfold, not just a status line, and it's the same picture you'd see on your desktop.

How It Works

• Everyone where they belong. Agents appear at their desk while working, in line when they have a question, in the lounge when free, or outside when offline, walking between these spots as their status changes.
• Rockets that build and launch. A run's rocket grows piece by piece as the agent edits, tests, and commits, then launches when the work ships, landing on your Shipped shelf. A failed run's rocket falls apart instead.
• The view follows the action. If something happens off-screen, like a launch or a failure, the camera glides over to show it, then back to where you were.
• Look around freely. Pinch and drag to explore the office, with zoom and a "Fit" button to reset the view. Tapping any agent opens their details.
• Accessible by design. Sound and vibration follow the list view's settings, and reduce-motion keeps everyone still and sends rockets straight to the shelf without animation.

Where to Find It

Open the Agent Office in the phone app and tap "Office" to switch from the list view; tap "List" to switch back. Available now to anyone using agents in their Effigate Command Center workspace, on iOS and Android, with no setup required.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own agents.

Summary

Effigate Command Center cleaned up how task details display in the phone app. Priority, Assignee, Sprint, Review agent and Due date now line up neatly, using the same tidy row style you already know from your phone's own settings.

What You Gain

Previously, these values sat at different distances from the edge of the screen depending on how long they were, making a task's details look uneven and occasionally hard to scan quickly. A long value could even push its arrow out of line with the rest of the row.

Now every value lines up against a single column of arrows at the edge of the screen, with a thin line separating each row and long values trimmed neatly with "…" instead of crowding the layout. The same tidy alignment now applies when you create or edit a task, and on runtime and Autopilot settings pages too.

Where to Find It

This fix is already live for everyone using the Effigate Command Center phone app on iOS and Android. There's nothing to turn on; just open any task to see it.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center on your phone.

Summary

Effigate Command Center tightened privacy across every part of Chat with Agents. Nothing in the chat screen itself looks different, but a series of fixes now close off ways a private conversation, or the work behind it, could have been seen by people who shouldn't see it.

What You Gain

Previously, a chat wasn't always as private as it looked. An agent could, in principle, read conversations beyond the one it was answering. Teammates on a shared project could occasionally find traces of someone else's chat through activity logs, and people who'd left a team could still see its chat list.

Picture two colleagues sharing a project and the same agent, each with their own private chat. Before this change, one person's activity around that agent could surface in places the other could see. Now every such path is scoped tightly to the people meant to see each conversation, so each chat stays private to its owner.

How It Works

• Agents only see what they're answering. An agent now reads only the chat it's responding to, or one explicitly linked to its task, never a broader history.
• Activity stays with its owner. Logs and activity tied to a chat are now as private as the chat itself, closing a path teammates could use to piece together someone else's conversation.
• Only agents you can see are chatable. The list of agents you can start a chat with now only shows agents you're allowed to see and use.
• Projects you can't open stay closed. You can only link a chat to a project you can view, so its documents are never handed to an agent for something you don't have access to.
• Deleting a chat really deletes it. Removing a chat now stops any agent working on it and clears its messages and files, instead of leaving work running in the background.
• Your chat list reflects your current teams. It shows only teams you're still on, pinned chats first, then by latest message rather than creation date.

Where to Find It

These protections are already active for everyone using Chat with Agents, on web, mobile, and desktop. There's nothing to turn on and no setting to change.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Effigate Command Center's phone app now offers the same chat experience as the web. Replies render properly, you can see an agent working in real time, attach files, and create or link tasks straight from a conversation, all without reaching for a laptop.

What You Gain

Until now, chatting with an agent on your phone was a noticeably thinner experience than on the web: replies arrived as plain text, there was no visibility into what the agent was doing while you waited, and there was no way to attach a photo or create a task from the conversation.

Now the phone app carries the full experience with you. Picture snapping a photo of a whiteboard sketch during a meeting and attaching it straight to a chat with an agent, then watching live as it reads the image and starts working, all from your phone. When the conversation reaches a clear next step, you can create a task from it on the spot, with the task linked back to the chat for anyone who wants the full story later.

How It Works

• Formatted replies and live steps. Replies render as proper Markdown, and you can see what the agent is doing, queued, starting, or working, with its steps visible live.
• Stop and reclaim. Stop a message that hasn't started yet and it returns to your box to edit; a queue holds anything you send while the agent is still answering.
• Attach photos and files, and start new chats from an agent's suggested conversation starters.
• Choose the right project. The project picker shows what each project gives the agent before you choose it.
• Create or link tasks. Turn a chat into a task, with the project chosen and the description drafted from the conversation, or link it to an existing task; tasks show their linked chats and a summary.
• A tidier chat list. Active and Archived tabs, pin, archive, and delete, updating live, with new chats created only once you send a first message.

Where to Find It

Available now in the Effigate Command Center phone app for iOS and Android, for everyone using Chat with Agents. No setup is required.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center on your phone.

Summary

Effigate Command Center fixed four small display issues in the desktop app's Agent Office, all found and confirmed while building the same feature for mobile. Shipped work, launch timing, and your team roster now all display accurately and consistently.

What You Gain

Previously, a run that was still finishing up could briefly appear as already shipped on your Shipped shelf, then disappear and reappear once it actually landed. A busy shelf could also lose track of older items when new ones arrived, and two runs finishing at the same moment could show up out of order. On top of that, if your team got smaller, an agent that had been sitting idle could be left in a spot that no longer existed in the office layout.

Those four issues are now fixed. Your Shipped shelf reflects what has actually shipped, in the order it happened, and the office always has a seat for every agent on your team, however the team's size changes.

How It Works

• Accurate shelf timing. A run now joins the Shipped shelf only once it has actually landed, not while it's still finishing up.
• Correct room on a full shelf. When the shelf is full, the oldest item makes room for a new one, rather than removing more than needed.
• Correct landing order. Two runs that finish at nearly the same time now land on the shelf in the order they actually launched.
• Everyone has a seat. When your team's size changes, every agent, whether idle or offline, is placed correctly in the new office layout instead of being stranded.

Where to Find It

These fixes apply automatically to the desktop app's Agent Office for every team using agents. There's nothing to turn on and nothing to configure.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Effigate Command Center now puts search at the top of Tasks, Board, Projects and Decisions, matching results as you type and respecting your filters. Chats also get real names: a chat shows its own title if you gave it one, or its agent's name if not, and you can rename any chat on web or phone.

What You Gain

Before this, search only worked on the Agents page. Finding a specific task on a busy board, or a decision buried in a long list, meant scrolling and squinting rather than typing a few words. Every chat with an agent was also just called "Chat," telling you nothing about what was inside.

Now you can type part of a title, a task ID, or a decision's message and jump straight to it. Every word you type has to appear somewhere, in any order, so "login crash" still finds "Crash on the login screen" even with the words reversed. And when you rename a chat to something like "Homepage copy," it keeps that name in the list from then on, instead of leaving you to guess which "Chat" is which.

How It Works

• Search everywhere it matters. Tasks and the Board match a task's title, ID (776, #776, or the full ID) and description. Projects match by name. Decisions match the title, task ID and message.
• All-words matching. Every word you type must appear, in any order, so you don't need the exact phrase to find what you're after.
• Clear empty state. When nothing matches, the page says so and offers a one-click way to clear your search.
• Chats show a real name. The chat list and an open chat show the chat's own title if it has one, or the agent's name otherwise.
• Rename on web or phone. On the web, use Rename from a chat's row actions or header. On the phone, long-press a chat or use the menu inside it. Clearing the name, or choosing "Use agent name," reverts to the agent's name automatically.

Where to Find It

Search is already live at the top of Tasks, Board, Projects and Decisions for every plan. Chat renaming is available to anyone using Chat with Agents, on web and phone.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Effigate Command Center changed how every chat message is handled behind the scenes. Chats used to quietly create a "Chat: …" task on your team's first project for every message; that's gone now, and chats run as conversations in their own right, tied to whichever project you actually picked.

What You Gain

Previously, every message you sent in a chat created a task behind the scenes, always in your team's very first project, regardless of what the chat was actually about. That task showed up on the board as "in progress," cluttering your view with entries that weren't really work items at all. It also meant a chat used whatever that first project happened to offer, rather than the project you'd chosen for the conversation.

Now a chat simply uses the project you picked for it, with its description, repositories, and documents attached properly, and nothing appears on your board for just having a conversation. If a message couldn't be answered, perhaps it timed out or lost its connection, the chat now tells you plainly why, instead of leaving you staring at a task that silently never finished.

How It Works

• No more hidden tasks. The old "Chat: …" tasks are gone from every board; any that existed were cleaned up automatically, with chat history left untouched.
• The right project, every time. A chat now draws on the project you picked, not an unrelated default.
• Conversation memory. The agent remembers what was said earlier in the same chat on the same machine, and catches up by reading past messages when it's on a different one.
• Reliable answers. Every message now gets a clear outcome, even if it was stopped, timed out, or lost its connection, and later messages wait their turn instead of arriving out of order.
• Files reach the agent. Anything you attach to a chat message is now delivered properly.

Where to Find It

This applies automatically to every chat in Effigate Command Center. If your team's agent machines are running an older desktop app, you may be asked to update it so chats keep working smoothly.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own agents.

Summary

Effigate Command Center's agent bot in Slack now behaves like a real chat, not a simple command responder. Messages are remembered, tasks can be created with a slash command, and a Slack conversation carries the same project context and task links as a web chat.

What You Gain

Previously, talking to an agent's bot in Slack felt disconnected from the richer chat experience on the web: there was no lasting memory between messages, no way to tie the conversation to a project, and creating a task meant guessing at what you'd typed rather than filling out a proper form.

Now a Slack thread with an agent's bot works like any other Effigate Command Center chat. Picture asking its bot a question in a thread, getting an answer, then a day later asking a follow-up in the same thread — the agent still remembers the earlier context, as it would on the web. When ready to turn the conversation into real work, a slash command opens a proper task form instead of a vague prompt.

How It Works

• Secure, one-time account linking. Linking your Slack account uses a private link shown only to you, valid once, expiring after 15 minutes.
• The same access rules as the web. You must be on the agent's team and allowed to use it; only a team admin or the agent's owner can connect or disconnect its bot.
• Create a task with a form. A slash command opens a task form where you choose the project, and the agent writes up the task and can start right away.
• Choose what the chat is about. Set the project a chat is focused on with a slash command.
• Fresh starts when you need them. Start a new chat, or keep the same one while asking the agent to forget what came before.
• Send files. Attach up to 10 per message, 20 MB each.
• Clear status in Slack. An hourglass shows while queued, an eye while working, clearing once it answers.

Where to Find It

Available now to any team using Chat with Agents that has connected an agent's bot to Slack. Sending files needs the Slack app's file-reading permission, which may require reinstalling the app.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Effigate Command Center's Chat now gives you more control over busy conversations. Messages sent while an agent is still working wait in a visible line you can reorder, agents can offer suggested starters, and every chat names itself from your first message.

What You Gain

Previously, sending a follow-up message while an agent was still answering was awkward: there was no way to see what was queued, reorder it, or pull a message back to rework it. Stopping an agent mid-answer could also leave an empty, unhelpful reply behind. And every new chat sat there called "Chat" until you renamed it yourself.

Now, if you think of something else to ask while an agent is mid-task, your message waits in a short, visible queue above the box. You can edit it, take it back, or send it immediately, which gracefully interrupts the current answer and keeps what it had already said. Starting a new chat with an agent that has conversation starters configured gives you a running start instead of a blank box, and the chat titles itself from your first message so your chat list is readable at a glance.

How It Works

• A queue you control. Messages sent while the agent works wait in order above the box; edit, reclaim, or promote any of them before the agent reaches it.
• Clean interruptions. Stop keeps whatever the agent had already said, or returns your message to the box if it hadn't started.
• Conversation starters. Give an agent up to three suggested prompts; they appear when someone opens a new chat with it, and picking one fills the box without sending.
• Chats name themselves. A new chat is titled from your first message, then refined with a short, descriptive title; any name you set yourself is never overwritten.
• A better chat list. Active and Archived tabs, search, pinned chats, and message previews, updating live.
• Safer deletes. Deleting a chat now asks you to confirm by typing "delete me," matching every other delete.

Where to Find It

These updates are live now in the Chat page for everyone using Chat with Agents. Conversation starters can be set per agent under Settings → General → Conversation starters.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to chat with your own agents.

Summary

Effigate Command Center's Chat page has been rebuilt from the ground up. Replies now render properly, you can attach files and write longer messages comfortably, and you can watch an agent's progress live instead of waiting in silence for an answer.

What You Gain

Chatting with an agent used to feel like sending a message into a black box: replies came back as plain text even with lists, code, or tables, there was no way to see what the agent was doing while you waited, and attaching a screenshot wasn't possible. A long chat also reloaded awkwardly, and leaving the page mid-message lost what you'd started typing.

Now a reply with a code sample displays as a proper code block you can copy with one click, a table renders as a table, and a diagram renders as a diagram. While the agent works, you see exactly what it's doing — reading files, running a command, or making an edit — with a running timer and a Stop button if you want to interrupt it. Attach a screenshot by pasting it into the box, and it shows up as a thumbnail you can open full size.

How It Works

• Formatted replies. Headings, lists, code blocks, tables and diagrams render properly, with a one-click copy button on every message.
• Room to write. The message box grows as you type, and an unfinished draft is kept if you navigate away and back.
• Attach files easily. Paste a screenshot or drop files onto the box, up to 10 per message, shown as openable thumbnails.
• Live progress. You see the agent's current step with a timer and a Stop button; once it replies, steps collapse into a summary with a link to the full transcript.
• Clear outcomes. If a message couldn't be answered, the chat explains why, and a stopped answer is marked stopped with the time it took.
• Smoother navigation. Long chats load older messages on demand, and archiving or deleting your chat moves you cleanly to the next one.

Where to Find It

The rebuilt Chat page is live now for everyone using Chat with Agents in Effigate Command Center, on the web app, with no setup required.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to start chatting with your own agents.

Summary

Effigate Agent, the desktop app, now carries the same Graphite colours as the web and mobile apps, along with a new app icon, tidier screens, and a handful of dark-mode fixes that make it easier to read at a glance.

What You Gain

Before this refresh, the desktop app's look and feel had fallen a little behind the web and mobile apps, and dark mode had a few rough edges — switches, chips, and selected rows that blended into the cards around them, making the interface harder to scan quickly. Large numbers like token counts also displayed as long, hard-to-read figures.

Now the desktop app matches the rest of Effigate, with a new icon on macOS, Windows, and Linux, and a menu-bar icon on macOS that follows your system's light or dark setting. Every page opens with a clear title and short description, tabs have icons for faster recognition, and token counts read in a friendly shorthand like 20.5M instead of a long string of digits. Dark mode now reads cleanly throughout, and the window opens directly in your chosen theme with no flash of the wrong colours.

How It Works

• New app icon across macOS, Windows, and Linux, plus a macOS menu-bar icon that follows your system theme.
• Matching chart colours to the web app, with the Graphite colour used for cost charts.
• Cleaner screens with titles, short descriptions, and icon-labelled tabs throughout.
• Friendlier numbers, such as token counts shown as 20.5M rather than long raw figures.
• One clear daemon control showing Start or Stop depending on whether it's currently running.
• Dark mode fixes for switches, chips, and selected rows that previously blended into their surroundings.
• No colour flash on launch — the window now opens directly in your chosen theme.

Where to Find It

Update to the latest version of the desktop app to get the new look automatically; no settings changes are needed.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

When an agent run stalls because its machine goes quiet, Effigate automatically queues it for one more attempt. A timing issue meant that retry could be cancelled before it ever had a fair chance to run — that's now fixed.

What You Gain

Previously, if the original run had first been queued more than two hours earlier, its automatic retry was cancelled almost immediately as "never claimed," so the task failed with an "exceeded retry limit" message without the retry ever truly getting its second attempt. That meant some runs that should have quietly recovered on their own instead failed and needed a manual restart.

How It Works

The retry now gets the full two-hour window to be picked up by an available machine, regardless of how long the original run had already been queued before it stalled.

Where to Find It

This is a background reliability fix with nothing to turn on — it applies automatically to every agent run.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

You can now genuinely pause an agent's run from the desktop app and pick it back up later, without losing any of its progress. Pausing stops the agent but keeps its work exactly as it was; Resume continues from that same point, even if you've closed and reopened the app in between.

What You Gain

Previously, there wasn't a reliable way to step away from a long-running agent task and come back to it without starting over or letting it keep consuming time on something you weren't ready to continue. Stopping a run meant losing its progress; letting it keep running meant it occupied one of the agent's active task slots the whole time.

Now, picture an agent deep into a complex task when you need to redirect its attention elsewhere: click Pause, and its in-progress copy of the project — including any unfinished changes — is kept safely on your machine, even if you quit the app entirely. When you're ready, Resume picks the work back up from exactly where it stopped. Agents that support ongoing conversations remember what they were doing; others start a fresh conversation pointed at the saved work. And because a paused run doesn't count against the agent's active workload, it's free to pick up other tasks meanwhile.

How It Works

• Nothing is lost on pause. The run's own copy of the project, with any unfinished changes, is kept on disk even if you quit the app.
• Continuity where it matters. Agents that support ongoing conversations continue their own saved conversation; other agents start fresh but build on the kept work.
• Frees up the agent. A paused run doesn't count toward the agent's active workload, so it can take on other tasks while paused.
• Stop acts on what you're viewing, rather than whichever run happens to be first in a list, and also works from the web app.
• Runs that edit your project folder directly can't be paused — the app tells you why if you try.

Where to Find It

Find Pause and Resume on the Tasks page in the desktop app, next to any agent run on your own machine.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A round of mobile fixes closes several frustrating gaps: files attached when creating or commenting on a task now actually appear on it, new tasks support a checklist just like the web, and content on Android phones no longer gets hidden behind the on-screen navigation bar.

What You Gain

Files added through the New Task form, or the image and paperclip buttons on an existing task, were previously stored but never shown anywhere on the task — so there was no way to confirm they'd been added. New comments had a similar issue, appearing without their attached files until the page was refreshed. Separately, manually created tasks had no way to add a checklist, and on phones with Android's 3-button navigation bar, the bottom of many screens was hidden underneath it and impossible to scroll into view.

Now attachments show up on the task the moment they're added, with a clear explanation if a file couldn't be attached rather than it silently disappearing. Comment files appear immediately rather than needing a refresh, and if one fails, the comment box is cleared so you're not left with a half-posted duplicate. New tasks gain a full Checklist section, letting you add and remove items created in order with the task, as on the web. And across the app, nothing sits under the Android navigation bar any longer.

How It Works

• Attachments appear on the task immediately, whether added from the New Task form or an existing task, with clear errors for anything that fails.
• Comment files show up right away, with the comment box preserved if a file fails so nothing posts twice.
• Label editing is more reliable, with a clear message if the label list can't load instead of doing nothing.
• A Checklist section on New Task, matching the web's add, remove, and ordering behaviour.
• Nothing hides under Android's navigation bar across task lists, forms, project and agent screens, board columns, and bottom sheets.

Where to Find It

Update to the latest version of the mobile app; all of these apply automatically with no settings to change.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The desktop app's Office tab has become a small isometric office built out of toy bricks, where you can see at a glance what every agent on your team is doing — working at a desk, waiting with a question, resting in the lounge, or off the clock on a bench outside.

What You Gain

Keeping track of a whole team of agents used to mean checking task by task, or reading a list of statuses with no sense of the bigger picture. It was hard to get an at-a-glance feel for how busy your team actually was, or who needed your attention right now.

Now, picture opening the desktop app and seeing your whole team laid out in a small office: agents sit at their desks with the tool they're using floating above their heads, line up by your desk when they need an answer, relax in the lounge when idle, or sit on a bench when offline. Every task in progress builds a small rocket on its agent's desk as it passes milestones, and when a task ships, the rocket launches with confetti and lands on a shelf of completed work for the day.

How It Works

• See what each agent is doing at a glance — at their desk, in line with a question, in the lounge when idle, or on a bench when offline.
• Every task builds a rocket on its agent's desk, one piece per milestone, so progress is visible without opening the task.
• Shipped work launches and lands on your Shipped shelf with confetti; a failed run's rocket falls apart instead.
• A notice board keeps a running count of what the team delivered today and what's waiting on you.
• Click any agent for its live activity feed, with Pause and Stop for runs on your own machine.
• Click yourself to see your own inbox of open questions and today's deliveries.
• Optional sound effects, off by default, and simple flat animation that pauses when the tab isn't visible.

Where to Find It

Open the Office tab in the latest version of the desktop app — it replaces the previous Office view automatically, with no setup needed.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Labels on the mobile app's task page now work exactly the way they do on the web, and tasks gain a new Sprint row, so you can move a task into any sprint of its project — or out of sprints entirely — directly from your phone.

What You Gain

Labels on mobile had a few rough edges: the list of labels you could add sometimes only showed options that weren't actually meant to be set manually, which — for most teams — meant every attempt to add a label quietly failed, even though it looked like it had worked. The label picker could also fail to open for some roles entirely. On top of that, there was previously no way to move a task between sprints from the mobile app at all.

Now the label picker lists only the labels you're actually allowed to apply, opens correctly for anyone who can edit the task, and shows each label's own colour as a chip, with special labels marked and a clear way to remove the ones you're allowed to change. And the new Sprint row on the task page lets you move any task into a different sprint, or out of sprints altogether, right from your phone — as long as you have permission to change the task's project.

How It Works

• Add shows only labels you can actually set, rather than ones reserved for automatic use.
• The label picker opens for everyone who can edit the task, not just certain roles.
• Chips show each label's colour, with special labels marked and removable ones showing a clear way to take them off.
• Permissions match the web app throughout.
• A new Sprint row on the task page lets you move a task into any sprint of its project, or remove it from sprints entirely.

Where to Find It

Both improvements are on the task page in the latest version of the mobile app, for anyone with edit access to the task.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A small readability fix for the Inbox: hovering over a notification now visibly highlights it, and the one you currently have open stands out clearly from the rest of the unread list.

What You Gain

Previously, hovering over an unread notification in the Inbox had no visual effect, and the notification you had open looked identical to every other unread one — making it easy to lose track of which item you were actually reading, especially in a long list.

How It Works

Hovering over a row now darkens it slightly, and the notification you currently have open gets a darker background with a highlighted bar down its left edge, in both light and dark mode.

Where to Find It

This applies automatically to the Inbox; there's nothing to configure.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

On some Mac systems, the desktop app could claim an update was ready to install, only for "Restart to update" to silently do nothing. The app now explains exactly what went wrong and lets you try again once it's resolved.

What You Gain

Previously, if an update failed to download or install — for example, because the operating system rejected it for a technical signing reason — the app gave no indication anything was wrong. Clicking the button meant to apply the update simply had no visible effect, leaving you to wonder whether it was working or stuck.

How It Works

• Clear explanations appear in the update banner and in Settings → Software update whenever an update can't be downloaded or installed.
• "Restart to update" shows its progress, displaying "Restarting…" while it works, or the specific reason if the install can't proceed.
• "Try again" re-checks for the update, so a corrected release installs normally once it's available.

Where to Find It

This applies automatically the next time an update is available; check Settings → Software update if you ever see an error.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A few small but welcome polish fixes on the web: the sidebar now clearly shows which page you're currently viewing, notifications display as readable cards with icons, and the "live updates paused" notice explains itself more clearly.

What You Gain

The sidebar had stopped reliably highlighting your current page, making it easy to lose track of where you were, especially in dark mode. Notifications were also harder to scan than they should have been. All three are now fixed: the active page is clearly marked, notifications show as a card with an icon so warnings stand out, and if your live connection ever drops, the notice now plainly says updates are paused and that the page will keep refreshing automatically every 20 seconds until the connection returns.

How It Works

• Sidebar highlighting restored for the current page, in both light and dark mode.
• Notification cards with icons make different types of notices easy to distinguish at a glance.
• A clearer live-update notice explains that updates are paused and the page is refreshing automatically every 20 seconds in the meantime.

Where to Find It

These changes apply automatically across the web app; there's nothing to turn on.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The Brick Office's live view of your agents is now genuinely live for runs happening on any machine on your team, not just your own, and finally plays its rocket-launch and failure animations reliably. A new Day/Night/Auto switch rounds out the view.

What You Gain

Runs happening on a teammate's machine previously looked frozen in the Office once the initial activity loaded — their transcript stopped updating, their progress stayed stuck at "Started," and their desk rocket never got past the launch pad, even while real work was clearly happening elsewhere. On top of that, the celebratory rocket launch when a task shipped, or the rocket falling apart when one failed, sometimes simply didn't play if the agent moved away from its desk too quickly.

Now every agent's activity streams live in the Office regardless of which machine it's running on, with the same real-time transcript, progress updates, and desk rocket animation you'd see for a run on your own computer. Shipped tasks reliably launch their rocket with confetti and land it on the next open spot on your Shipped shelf — making room by retiring the oldest rocket if the shelf is full — and failed runs reliably show their rocket falling apart. A new lighting switch lets you set the Office to Day, Night, or Auto, which follows the clock and switches to night lighting from 7pm to 7am, remembered per computer.

How It Works

• Live activity from every machine — transcripts, progress, and desk rockets update in real time no matter where the run is happening.
• Reliable launches and failures. Shipped tasks always launch and land on the Shipped shelf; failed runs always show the rocket falling apart.
• A full shelf makes room automatically by retiring its oldest rocket first.
• Day / Night / Auto lighting, with Auto switching to night from 7pm to 7am and your choice remembered per computer.
• A taller office so the notice board no longer pokes above the walls.

Where to Find It

Open the Office tab in the latest version of the desktop app; the lighting switch sits at the top of the view.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Assigning an agent to a task from the mobile app used to show the agent on the task without ever actually starting its work. That's fixed — assigning from mobile now behaves exactly like assigning from the web.

What You Gain

Previously, tapping to assign an agent from your phone looked like it worked — the agent's name appeared on the task — but nothing actually happened behind the scenes, leaving you to notice later that no progress was being made and start the run some other way. Now the agent starts immediately if the task is ready to go, and if it's sitting in a waiting status like Open or Backlog, the task clearly explains why it hasn't started yet instead of leaving you guessing.

How It Works

• The agent starts right away when the task is ready; a note explains the delay if the task is still in a waiting status.
• Sub-tasks are handled properly — if the task has sub-tasks, you're asked whether to assign them to the same agent, and they're queued to run one at a time in order, just as on the web.
• Re-assigning cancels the previous pending run, so you never end up with two agents working the same task.
• The same fix covers the board, the CLI, and older app versions, not just the newest mobile release.

Where to Find It

Assign an agent to any task from the mobile app exactly as before — the fix applies automatically with no extra steps.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

AI Chat in the mobile app previously ended every conversation with a "Could not reach the AI" error, even when the assistant had actually replied — that's fixed. On top of the fix, mobile now shows the same rich, editable task cards the web app has, so you can review and create tasks the AI proposes right from your phone.

What You Gain

The mobile app couldn't properly read the AI's reply as it streamed in, so every conversation ended in an error message regardless of whether the assistant had actually responded — making AI Chat effectively unusable on mobile. Beyond the fix, task proposals from the AI had no equivalent of the web's task cards on mobile, so there was no good way to review, adjust, and create the tasks an AI conversation suggested without switching to a computer.

Now a conversation with the AI assistant completes properly on mobile, and when it proposes tasks, you get the same kind of card you'd see on the web: each editable before you create it, covering title, description, type, priority, weight, dates, and checklist. Create tasks one at a time, drop them into an active sprint or leave them unassigned, or create every proposed task at once. If a sub-task is part of a bigger breakdown, it keeps its connection to the parent task even if created separately, and any dates or weight the AI suggested are no longer lost.

How It Works

• Conversations complete reliably — replies, clarifying questions, and task proposals all display correctly.
• Editable task cards, matching the web: title, description, type, priority, weight, dates, and checklist.
• Flexible creation — one at a time, into an active sprint, with no sprint, or all at once.
• Sub-tasks keep their parent even when created individually from a breakdown.
• Created and skipped tasks are remembered if you reopen the conversation later.
• Clearer error messages when something goes wrong — no connection, an expired session, no project access, too many requests, or an AI provider issue.

Where to Find It

Update to the latest version of the mobile app; AI Chat is available wherever it was before, now with the same task-card experience as the web.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A small but noticeable fix: the lighter parts of the Effigate "E" logo were hard to see on light backgrounds and too dark on dark ones. They now use a consistent mid-grey tone, so the logo looks right everywhere it appears.

What You Gain

If you'd switched between light and dark mode, or simply viewed Effigate in different places, you may have noticed the logo looking washed out in one theme or the other. That's now fixed with a single consistent shade that works well against both light and dark backgrounds.

How It Works

The Effigate "E" now uses the same mid-grey tone as the app icon everywhere it appears — in the web and mobile apps, in emails, and across both light and dark themes — so it's always clearly visible.

Where to Find It

This applies automatically everywhere the Effigate logo appears; there's nothing to change.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The web app now matches the mobile app's Graphite colour palette, with a new grey "E" logo and favicon, and — for anyone who's been waiting for it — proper dark mode.

What You Gain

Before this update, the web app only came in one look, with no way to switch to a darker theme for evening work or personal preference, and its colour palette and logo were due for a refresh. Now you can choose Light, Dark, or System from the user menu or your profile page, and your choice is saved to your account, so it follows you across browsers and devices and the page loads in the right theme immediately, with no flash of the wrong colours while it loads.

Charts throughout the app use a new set of colours chosen to stand out clearly against the Graphite interface in both themes, and the same look now carries through to emails, the help centre, and the sign-in pages, so the experience feels consistent from the moment you sign in to the moment you read a notification in your inbox.

How It Works

• Dark mode, with Light, Dark, or System options in the user menu or your Profile page.
• Your choice is saved to your account and follows you across browsers, with no flash of the wrong theme on load.
• Updated chart colours designed for clarity in both light and dark mode.
• A consistent look everywhere — emails, the help centre, and sign-in pages all use the new palette.
• Customer Portal workspaces get the Graphite accent by default, while workspaces that already chose their own accent colour keep it.

Where to Find It

Pick your theme from the user menu (top right) or your Profile page; no setup is required otherwise.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The Effigate mobile app gets a batch of reliability and usability improvements: home-screen widgets now open the app properly every time, Tasks can be filtered down to one project and sprint, each task shows its agent's current run stage at a glance, and a new Graphite colour theme rounds things out.

What You Gain

Home-screen widgets could previously leave the app stuck on a loading spinner, especially right after unlocking your phone, with no way to recover except force-closing it. And on a busy workspace, the Tasks list showed everything at once, with only a status filter to narrow it down — making it hard to focus on just the sprint or project you cared about on a small screen.

Now a tap on a widget opens the app and keeps trying until your sign-in loads, telling you what it's waiting for and offering to continue if it takes more than a few seconds. Tasks can be filtered by project, then by one of its sprints or tasks with no sprint, with active filters shown above the list and cleared with a tap. And each task shows its agent's live status right there, with its own colour, so you can tell at a glance whether an agent is working, idle, blocked, in error, or offline.

How It Works

• Widgets that actually open. A failed sign-in read is retried automatically, with a status message and a manual option if it takes too long; Android widgets now open the app at all.
• Filter Tasks by project and sprint, alongside the existing status filter, with active filters shown above the list.
• Live run-stage badges on each task, naming the working agent and showing queued runs.
• Colour-coded agent status: Working, Idle, Blocked, Error, Offline.
• Pick a task's review agent on mobile, the same options you'd see on the web.
• New Graphite colour theme and a refreshed grey palette across backgrounds, cards, and text, in light and dark mode.

Where to Find It

Update to the latest version of the Effigate mobile app; the new filters live on the Tasks tab, and the Graphite theme is under Appearance in Settings.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

It's now clearer when a task already has an agent working on it, so you don't accidentally queue a duplicate run — and merging the pull request now stops any agent still working on it, instead of letting it run on after the work is done.

What You Gain

Before this update, there was no clear signal that a task already had an agent working on it. It was easy to mention the agent again, not realizing that queued a second, redundant run — one that could fail long after the first finished, leaving a completed task looking stuck or broken. And once a pull request merged, any agent still technically "working" on it kept going anyway, wasting time and causing confusing failures on work already done.

Now, open a task with an agent on it and you'll see a live banner naming the agent, when it started, and how many runs are queued behind it, on web and mobile, updating in real time. If you mention that agent again or send feedback while it's working, Effigate warns you that this starts another run, with a one-tap option to leave a note instead. The moment the pull request merges, anything its agents were still doing is stopped automatically, with the task recording what was stopped.

How It Works

• A live status banner on the task shows the working agent, when it started, and how many runs are queued.
• A warning before you duplicate work. Mentioning a busy agent flags that this queues another run, with a quick way to post a note instead.
• Clear run status on every comment that triggered one: Queued, Running, Done, Failed, or Stopped.
• Merging stops leftover work. Once a pull request merges, any agent still working on the task is stopped, and the task records what was cut short.
• Stopping a run really stops it, immediately, from the task, a chat, or a merge — it can't resurface as a failure.

Where to Find It

The status banner and warnings appear automatically on any task with an active or queued run. The improved stop-on-merge behaviour needs the latest desktop app and CLI to take full effect on runs on your own machines.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Effigate can now send one email each morning instead of a separate notification for every comment and status change. Turn it on in your notification settings, and each project gets a single digest leading with what needs you, followed by what got done and what's stuck.

What You Gain

Before the digest, staying on top of a busy project meant wading through a notification for every comment, status change, and mention — useful in the moment, but exhausting across several active projects, especially if work happened overnight or over a weekend. Important things like a review waiting two days for your attention could get lost in the noise of smaller updates.

Now, picture waking up to one email for each project your team works on: it opens with exactly what's been waiting on you — reviews of your work, unanswered mentions, failed runs nobody's retried, blocked tasks — then summarizes what got done, where tasks you're following stand, what's stuck, and whether the sprint is on track. A project where nothing happened overnight still gets a short "all quiet" note, so you know the digest is working rather than wondering if something slipped through. Managers get a team-wide summary on top: who needs a nudge, the longest-waiting work, and how each project and agent is performing.

How It Works

• Team members get one email per project, opening with anything that's waited 2+ days for them, then recent activity, follow status, and sprint health.
• Managers and admins get one team summary covering who to check in with, the longest waits, delivery by project, and how time is spent across agent work, queueing, and waiting on people.
• Slack delivery, if connected: each project's digest posts to its own channel, the team summary to your default channel.
• A Monday catch-up covers the full weekend in one email instead of three.
• Ordinary notifications pause once the digest is on — comment and status-change emails and Slack posts stop, while in-app, push, and urgent merge-conflict alerts still arrive right away.

Where to Find It

Turn it on in Settings → Notifications; use Send me a test digest to preview yours first, and turn it off again any time from your profile's email preferences.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

If you'd set a specific Slack channel for a project, it may never have received a notification — with no warning anything was wrong. Effigate now checks the channel when you save it, joins public channels automatically, and keeps notifications flowing to your default channel if a project channel has a problem.

What You Gain

Previously, choosing a dedicated Slack channel for a project could silently fail: a typo in the channel name, an archived channel, or a private channel Effigate hadn't been invited to would all cause every notification meant for that channel to disappear, with the project owner none the wiser. The only workaround was to clear the setting and let everything fall back to the default channel, losing the per-project organization teams wanted in the first place.

Now, picture setting up a new project's Slack channel: you type the channel name or paste its link, and Effigate checks it immediately, telling you right away if there's a typo, the channel's archived, or it's private and needs an invite. For a public channel, Effigate joins it automatically, with no separate invite step. A Send test message option lets you confirm notifications are actually arriving before you rely on it. And if a channel that used to work ever starts rejecting messages, nothing is lost — the notification goes to your default channel instead, with a note about where it was meant to go, and a clear warning on the project until it's fixed.

How It Works

• Checked when you save. Type #channel-name or paste the Slack channel link; typos, archived channels, or channels Effigate can't reach are flagged immediately.
• Automatic joining for public channels. No separate step to invite the app.
• Send test message. Confirm a channel is working, with Slack's own explanation shown if it fails.
• A safety net, always. If a project channel starts rejecting messages, notifications fall back to your default channel with a note, and the warning clears once a message gets through.

Where to Find It

Set or update a project's Slack channel from the project's settings; the check and test-message option appear right there. This needs your workspace's Slack connection to already be set up by an administrator.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Every time a task's status changes, Effigate now keeps a permanent record of the move: the status it left, the one it entered, who or what made the change, and how long the task sat waiting before that happened. This lays the groundwork for clearer reporting on where time actually goes.

What You Gain

Before this, a task's current status was visible, but its history wasn't — there was no reliable way to see how a task actually moved through your workflow, how long it waited at each stage, or who was responsible for moving it along. That made it hard to answer simple questions like "why did this sit in review for three days?" without reconstructing events from scattered comments.

Now every transition is captured automatically, including ones that used to leave no trace at all: an agent starting work, a failed run sending a task back to the backlog, a merged pull request closing it out, or a sub-task being released to run next. When an agent moves its own task, the record credits the agent by name rather than whoever happens to own the machine it ran on, and sending work back with feedback is recorded distinctly from a plain status change. Teams can now see, task by task, exactly how work actually flowed.

How It Works

• Every kind of move is recorded, including ones driven by automation: an agent run starting, a failed run returning a task to the backlog, a pull request merge closing it, and a sub-task being released once its turn comes.
• Credit goes to the right actor. A status change made by an agent is attributed to that agent, not the person whose machine happens to run it.
• Feedback is distinguished from an ordinary move when work is sent back with a comment explaining why.
• History can be extended backward from your existing activity records for teams that want it, though moves your workspace's activity log never captured can't be recovered.

Where to Find It

This records automatically going forward for every task in every project — there's nothing to turn on. It's the foundation for upcoming reporting on waiting times and where task time goes.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

You no longer need to refresh the page to see what a teammate or an agent just did. Labels, comments, attachments, the activity timeline, and the project overview now update live, matching the fields that already did — status, priority, dates, and checklists.

What You Gain

Before, only a handful of task fields updated automatically while you watched. Everything else — a new label, a file dropped into a comment, a reaction, the run log, token usage, even the parent-and-sub-task list — only appeared after a manual refresh. On a busy board with several agents working at once, that meant constantly reloading to keep up.

Now picture a project overview with three agents running tasks at once: as each adds a comment, updates a checklist, or finishes a run, you see it appear immediately, without touching refresh, whether you're on the task, the Kanban board, the Sprints & Tasks tab, or the overview's counts and recent-tasks list. If your connection to live updates drops, Effigate quietly checks for changes every 20 seconds instead, so you're never more than moments behind — with a plain notice if it's been struggling for a while.

How It Works

• Nearly everything on a task is live — labels, subscribers, parent and sub-task lists, the activity timeline, attachments, comment reactions and files, the run log, and token usage.
• The project overview updates live too, including its counts, recent tasks, and your personal task lists, alongside the board and Sprints & Tasks tab.
• A safety net when the connection drops. Open screens fall back to checking every 20 seconds; after a short delay you see a plain "Live update is not working" notice, which clears itself once the connection returns.
• Your typing is protected. A teammate editing a task's title or description while you're typing in the same field no longer overwrites what you're writing.
• The activity timeline remembers your preference for collapsed or expanded, per task.

Where to Find It

This is on by default for every task, board, and project overview — there's nothing to turn on. It needs the live-updates connection your Effigate workspace already uses; if that connection is ever unavailable, the fallback refresh keeps you current automatically.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Two reliability fixes tighten up how automatic reviews and GitHub pull requests connect to your tasks. Reviews that keep ending without a clear verdict now stop retrying instead of looping, and a task can no longer mistakenly adopt a pull request from an unrelated repository as its own.

What You Gain

Previously, a commit could be reviewed again and again if each automatic review happened to end without producing a verdict, since the system only recognized a review as "finished" once a verdict was recorded. A commit stuck in that state could trigger review after review with no end in sight. Separately, any pull request that happened to mention a task's identifier — even from an unrelated repository — could become that task's main pull request, get reviewed as if it belonged to the task, and close the task automatically when merged.

Both are now tightened. A commit gets at most two automatic reviews that end without a verdict; after that, no further automatic review starts, and the task's history explains why. You can still start a review yourself at any time, and a new commit resets the count. A pull request only becomes a task's own when it comes from a repository registered to that project; pull requests from anywhere else are shown for reference, but no longer drive reviews or close tasks.

How It Works

• A review cap, not a retry loop. Two unresolved automatic reviews of the same commit is the limit; the task's timeline records that no further review ran and why.
• Manual reviews are unaffected. You can still start a review yourself at any point, regardless of the automatic cap.
• A fresh commit resets the count. Pushing a new commit to the task gives it a clean slate for automatic reviews.
• Pull requests stay scoped to their project. A pull request only counts as a task's own when its repository is registered on that task's project; otherwise it's linked for reference only, with a note in the task's history.
• No change for simple setups. Projects with a single registered repository behave exactly as before.

Where to Find It

Both fixes are live on the server already and need no app update to take effect.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Every agent run in Effigate Command Center now works inside its own private copy of your project, created when the run starts and cleared away when it ends. Your own checkout is never touched, and the whole chain of setup, handoffs, and reviews is more honest about what happened.

What You Gain

Before this update, agent runs worked directly against the same project files you had open, so a run that crashed partway through could leave half-finished edits in your working copy, confusing the next task. A run could also say it had finished while leaving changes uncommitted or unpushed, so the task looked done when nothing was actually saved.

Picture an agent starting work on a task: Effigate gives it a fresh, disposable copy of your project on its own branch. The agent edits, tests, and commits inside that copy, and when the run ends, the copy disappears, leaving your project exactly as you left it. If a run claims to be finished but changes were never committed or pushed, the task is marked failed and says why. A dependent task picks up its work in order, instead of two runs tripping over the same branch.

How It Works

• A disposable workspace per run. Each run gets its own copy of the repository on the task's branch, removed once the run ends.
• Honest completion checks. A run that reports done while leaving uncommitted or unpushed changes is recorded as failed, with the reason shown on the task.
• Full context for every run. Agents receive the right instructions for the kind of run they're on — a first pass, a review, a rework, or a retry — plus your project's saved lessons and reference documents.
• Reviews check the exact version. A review always looks at the specific commit it was asked to judge, not whatever is on disk.
• Dependent tasks run in order. Related sub-tasks work one at a time from the same branch, handing off cleanly.
• Project setup runs automatically before an agent starts working.

Where to Find It

This applies automatically once your desktop app and CLI are updated to the latest version; older versions keep the previous behaviour until updated.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The sidebar had grown into one long, unbroken list of links that made it harder to find what you needed at a glance. It's now organized into short sections named for what you actually do there, and you can fold any section away to keep the ones you use most front and center.

What You Gain

As more features were added over time, the sidebar's "Workspace" area had become a long single list, with related items like Customers and Roles ending up grouped in places that didn't match how most teams think about them. Finding a specific page meant scanning past everything else first.

Now the sidebar is split into seven short, clearly labeled sections — such as Work, Agents, Insights, and People — each holding only what belongs there. Nothing was added or removed, and what you can see is unchanged; a section you don't have access to simply doesn't appear. If you mostly live in Agents and rarely touch Finance or HR, you can fold those away and keep your sidebar focused on what you actually use.

How It Works

• Seven short sections replace the old single list, each named for what you do there — for example Work (Board, Projects, Calendar), Agents (Agents, Chat, Autopilots), and Insights (Agent Usage, Analytics).
• Dashboard, Inbox and Decisions stay at the top, unsectioned, since they're used constantly.
• Click a section's title to fold it away. Your choice is remembered, so your sidebar stays the way you left it.
• A section never hides the page you're currently on, even if you'd folded it away earlier.

Where to Find It

The new sidebar layout is already live for every account — there's nothing to turn on. Click any section title to fold or expand it.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A parent task and its sub-tasks now run as one ordered line of work instead of several agents working on them all at once. Each sub-task's work is merged in before the next one starts, so the work builds cleanly on what came before it, and a problem anywhere in the sequence is visible exactly where it happened.

What You Gain

Running several sub-tasks of the same parent at the same time could mean each one started from a slightly different starting point, and reconciling their separate pieces of work back together afterward took more coordination than it should have. It also made it harder to tell, at a glance, what order things were actually happening in, or where a breakdown of work currently stood — even after sub-tasks stopped running at the same time as their parent, they could still run out of order with each other.

Now the sequence is explicit and visible. The parent task runs first to confirm the plan, then its sub-tasks run one after another — each one's work is completed and merged in before the next begins, so every sub-task builds on a known, up-to-date foundation. If something in the sequence runs into trouble, the whole line pauses right there with a clear explanation, rather than other sub-tasks continuing on top of an unresolved problem.

How It Works

• The parent task runs first, checking that the breakdown of sub-tasks makes sense before anything else starts.
• Sub-tasks then run one at a time, in a clear order based on how they're organized on the board.
• Each sub-task's work is merged in before the next one begins.
• The parent runs once more at the end, after every sub-task is finished, to bring everything together.
• A problem stops the sequence visibly where it happened, with the reason shown on the affected sub-task. Resuming it picks the sequence back up.

Where to Find It

This applies automatically to every task broken into sub-tasks — there's nothing to configure. Keeping the desktop app and CLI current ensures agents are given the clearest picture of where the sequence stands.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

When a run was routed to a squad leader, or an agent had been granted access to specific connector accounts, that context wasn't reliably making it to the agent at the start of the run. Both now reach the agent properly, along with a small formatting fix to how agents open their comments.

What You Gain

If you'd set up a squad with a leader and members, or granted an agent access to particular connector accounts, you'd reasonably expect the agent to actually know about that setup when it started working. Instead, that information wasn't being delivered, which meant a squad leader might not act like one, and an agent with connector access might not reliably pick the right account to use.

Now a squad leader's run tells it clearly that it's leading the squad, who its members are, and how to hand off work to them. An agent granted connector accounts is told exactly which accounts it has and which one is the default, so it can choose correctly without guessing.

How It Works

• Squad leaders now receive their full briefing — their role, their members, and how to delegate — at the start of a run.
• Granted connector accounts are now listed for the agent, including which one is the default.
• Agents are told not to repeat a task's title as a heading in their own comments, since it's already shown separately.
• A chat about a specific project now gives the agent that project's actual documents and overview, rather than defaulting to an unrelated project.

Where to Find It

This applies automatically wherever you use squads or connector accounts — there's nothing to configure.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A reviewer agent runs on a specific machine, and if that machine was offline when a review was queued, the review used to wait briefly, fail quietly, and never be looked at again — with the pull request sometimes merging with no review at all. Reviews now tell you immediately when this happens, and pick themselves back up automatically once the machine reconnects.

What You Gain

This gap was easy to miss: a pull request could look like it had simply skipped review, with no clear reason why, until someone went digging and realized the machine the reviewer needed had been offline at the critical moment. In the meantime, that code could already be merged with nobody having actually looked at it — not a great position to discover after the fact.

Now you're told right away if a review is waiting on a machine that isn't currently connected, naming which reviewer and which machine it's waiting for. If the machine comes back online before anything else has reviewed that same code, the review picks up automatically, with no need for anyone to manually re-trigger it.

How It Works

• You're notified immediately if a review is queued for a machine that isn't currently online, with the reviewer and machine named clearly.
• The review resumes automatically once the machine reconnects, as long as the pull request is still open at the same commit and nothing else has reviewed it since.
• Reviews are stricter about exactly which commit they look at — they always check the precise commit the review was opened for, so a later change gets its own fresh review rather than being silently skipped or double-counted.
• A commit that no longer exists (for example, if the branch history changed) ends the review cleanly with that explanation, rather than retrying endlessly.

Where to Find It

This applies automatically to every project with agent-driven review — there's nothing to configure. The notification and auto-resume take effect immediately; keeping the desktop app and CLI current ensures the rest of the reliability improvements apply too.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Some projects weren't showing up where you'd expect them — in the Agent Usage project filter, the Calendar, or Autopilot setup forms — even though totals elsewhere clearly counted activity from them. The underlying link between a project and its team is now set correctly, so every project appears consistently everywhere your team's projects are listed.

What You Gain

Before this fix, a project created directly in the web app could end up missing from several places that list "your team's projects," even while still showing up in overall totals. That mismatch was confusing: you'd see activity from a project in one summary, then be unable to find or select it in a dropdown elsewhere. Any existing projects affected by this were also corrected, so the fix applies retroactively, not just to new projects going forward.

How It Works

• New projects are now correctly linked to the team they're created in, so they appear everywhere that team's projects are listed from day one.
• Existing projects that were affected have already been corrected — no action needed on your part.
• This fixes the project list on Agent Usage, the Calendar, Autopilot's create and edit forms, and the desktop app's project list.

Where to Find It

This applies automatically across your account — there's nothing to turn on or re-link yourself.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

There used to be two separate answers to "what's the latest desktop app version" behind the scenes, which could drift apart and cause machines to be mislabeled as out of date — or not flagged when they actually were. There's now a single, authoritative source, so that can no longer happen.

What You Gain

Previously, the version used to decide whether your desktop app or CLI was out of date could fall out of sync with the actual latest release available for download, even after releases were fixed to always include the latest fixes. That mismatch meant a machine running the true latest version could potentially still be incorrectly flagged as outdated, or vice versa.

Now there's one place that version comes from, used consistently everywhere it's checked, so what you see about "the latest version" always matches what's actually available to download and install.

How It Works

• One source of truth for the latest version, used consistently for update checks and for flagging outdated machines.
• Reported separately per platform (Windows, macOS, Linux); if they ever briefly differ during a rollout, the version used for comparisons is the one every platform has already reached.
• If the version can't be determined for some reason, no machine is incorrectly flagged as outdated in the meantime.

Where to Find It

This applies automatically — there's nothing to configure. Check for updates from inside the desktop app as usual.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Setting up or updating an agent now gives you the newest AI models right in the Model dropdown, instead of requiring you to know and type an exact model identifier yourself.

What You Gain

Keeping an agent on the best available model used to mean knowing the exact name of a new release and entering it correctly — an extra bit of friction most people would rather skip, and one that made it easy to miss out on a better or faster model simply because you hadn't heard the exact right name yet.

Now the newest models from the leading AI providers are available to pick directly from the dropdown when you set up or edit an agent. New agents you create default to a current, well-rounded model, so you get sensible behavior out of the box, while still being free to pick something else for a specific agent's needs.

How It Works

• The Model dropdown lists the newest AI model releases, so you can switch an agent to a newer model in a couple of clicks.
• New agents default to a current, well-balanced model automatically.
• Existing agents keep whatever model they're already set to — nothing changes unless you choose to switch it.
• An older model nearing retirement is removed from the list for new selections; if one of your agents is still using it, you'll want to switch that agent to a current model before the older one stops being available.

Where to Find It

Pick a model for any agent from its settings page, under the Model dropdown.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Clicking Help in the sidebar previously opened the Help Center's page unstyled, inside a small pop-up over whatever you were working on. It now opens the Help Center properly, in a new tab, matching the help icon elsewhere in the app.

What You Gain

The pop-up version was hard to read and easy to dismiss by accident, which made the sidebar's Help link less useful than it should be for actually finding an answer. Opening it as a full, properly styled page in a new tab makes the Help Center easier to browse and keeps your original page exactly as you left it.

How It Works

• Help now opens in a new browser tab, showing the Help Center's normal, styled page.
• Matches the help icon in the top bar, so Help behaves consistently no matter where you click it from.

Where to Find It

Click Help in the sidebar, or the help icon in the top bar, to open the Help Center in a new tab.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Saving a change or deleting something — a label, for example — could occasionally fail with a "Page Expired" error, even though nothing was actually wrong with your session. The underlying conflict causing it has been resolved, so saves and deletes now go through reliably.

What You Gain

This error was especially confusing because it seemed to happen at random: it had nothing to do with how long you'd been logged in, and a fresh browser session was never affected, while a browser that had recently visited certain other sites could run into it repeatedly for up to a couple of hours at a time. That inconsistency made it hard to pin down and frustrating to run into, since retrying usually "just worked" without explaining why it had failed in the first place.

The app now sends its own security confirmation directly with every save or delete, rather than relying on a browser cookie that could occasionally be overwritten by an unrelated site. That removes the source of the conflict entirely, so this error should no longer occur.

How It Works

• Saves and deletes now carry their own security confirmation directly, instead of depending on a cookie that could be affected by other sites you'd visited.
• No action needed on your part — this takes effect automatically across the app.

Where to Find It

This fix applies automatically everywhere you save or delete something in the app.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A recent Windows desktop app release could show a "Could not load dashboard stats" error and appear to have no task history. The cause was a packaging mistake in that release, now fixed — and if your history was affected, the next update restores it automatically.

What You Gain

If you ran into this, your local dashboard looked broken and your history seemed to have vanished, which is understandably alarming even though your actual task and project data on the server was never affected. The fix corrects how the Windows build is packaged going forward, and the app also now double-checks itself during packaging so a mismatch like this can't ship again.

For anyone affected, there's nothing to do differently: updating to the current desktop app version resolves the error and brings your local history back on its own.

How It Works

• The Windows build is now packaged correctly for every release going forward.
• If your local history was affected, it's restored automatically the first time you open the updated app, whether you update from inside the app or reinstall it.
• macOS and Linux were never affected by this issue.

Where to Find It

Update to the current desktop app version from inside the app, or download it fresh from your account's download page.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A sub-task is meant to build directly on the work of the sub-tasks before it. If its proper starting point couldn't be prepared on a machine for some reason, it used to quietly start from the wrong place instead and carry on as if nothing were wrong — producing work that looked complete but was actually missing earlier progress. It now fails clearly with the reason instead, so this can't happen silently.

What You Gain

This was a particularly deceptive kind of failure: everything looked normal, the agent did real work and opened a pull request, but that work was missing the earlier sub-tasks it should have built on, and it ended up going to the wrong destination entirely. Nothing on the task said why, which meant the mistake could go unnoticed until someone reviewing the actual change realized something didn't add up.

Now, if a sub-task's proper starting point can't be prepared — for example, because of a temporary connection issue — the run fails immediately with a clear reason shown on the task, rather than silently substituting the wrong starting point. It's treated like any other failed run: retried automatically when that's likely to help, and if it still can't proceed, the task is marked as blocked until the underlying issue is resolved.

How It Works

• A sub-task that can't reach its proper starting point now fails immediately, with the specific reason shown on the task.
• It's retried automatically when a retry is likely to succeed.
• If it still can't proceed, the task is marked blocked, pausing the rest of the sequence until it's resolved.
• A sub-task also no longer starts from a stale copy of its parent's work — it always uses the current, up-to-date version.

Where to Find It

This applies automatically to every task broken into sub-tasks. Keeping the desktop app and CLI current ensures you get the full benefit of this fix.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A particular sequence of events could cause the same piece of already-merged code to be reviewed, approved, and merged again and again on a loop — in one case dozens of times for a single commit. That loop is now closed: a commit that's already been reviewed and merged for a task is recognized as such and left alone.

What You Gain

This kind of loop wasted review capacity on work that was already finished and merged, and created noisy, repetitive activity on the affected task that had nothing useful to show for it. It happened because the system occasionally recognized "already reviewed" by looking at the pull request itself rather than the actual commit inside it — so a new pull request opened for a commit that had already been reviewed and merged would be treated as brand new, when it should have been recognized immediately.

Now the check looks at the commit directly, so a pull request can't trigger a repeat review or a repeat auto-merge of something that's already done. A genuinely new commit is still always reviewed as expected — only an exact repeat is skipped.

How It Works

• A review no longer starts for a pull request whose exact commit has already received a verdict elsewhere on the same task.
• Auto-merge no longer merges a pull request whose commit was already merged for the same task; it's left open with a note explaining that it duplicates already-merged work.
• A genuinely new commit is always reviewed as normal — this only skips an exact repeat, never a real change.
• The task's own activity history explains when and why a review or merge was skipped, so nothing happens invisibly.

Where to Find It

This applies automatically to every project using agent-driven review and auto-merge — there's nothing to configure.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

The single most common reason an agent run failed to even start was a leftover file from a previous run sitting in the shared folder it worked in. Agent runs on the same machine no longer share that folder: each run now gets its own isolated, disposable copy of your project's code, used only for that run and cleaned up automatically when it ends.

What You Gain

Previously, every agent run on a given machine worked inside the same local copy of your project. If one run left anything behind, every later run on that machine could be refused outright, simply because the folder wasn't in the clean state expected. The fix usually meant someone manually clearing out that shared folder.

Now each run works in its own private copy, created fresh before anything starts and discarded the moment the run ends, however it ends. Your project's actual folder is never touched directly. Three agents working on three different tasks at the same time now each work entirely inside their own copy, so nothing one agent does can collide with another.

How It Works

• Every run gets a fresh, disposable copy of your project's code, removed automatically once the run ends.
• You can save an optional setup script per project that prepares a fresh copy before the agent begins working; without one, the agent installs what it needs itself.
• Unfinished work is reported honestly. Work left uncommitted is discarded with the copy; committed work is kept.
• A run that can't get the access it needs fails immediately with a clear reason.
• Code reviews work the same way, examining the pull request in their own disposable copy.

Where to Find It

This applies automatically to every project and every agent run — there's nothing to turn on. An optional setup script can be added from a project's Resources settings.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

When an agent posted a comment on a task, the email, inbox entry, push notification, and Slack message about it previously credited the person whose machine the agent ran on — making it look like a colleague had written something an agent actually wrote. Notifications now correctly name whoever, or whatever, actually wrote the comment.

What You Gain

This small mismatch could cause real confusion: a teammate getting credit (or blame) for a comment an agent wrote, simply because the agent happened to run on their machine. For a team that relies on being able to tell agent activity apart from human activity at a glance, that made notifications genuinely misleading.

Now every notification about a new comment names the actual author — the agent's name for a comment it wrote, a system label for automated notes like a GitHub merge update, and the person's own name for comments they wrote themselves — matching exactly what you already see in the task's comment thread.

How It Works

• Notifications now match the comment thread's own attribution — whatever name you see on a comment in the task is the same name used in the email, inbox entry, push notification, and Slack message about it.
• Applies to every notification channel you have connected, with no settings to change.

Where to Find It

This applies automatically to every notification you receive about task comments going forward.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A project's saved lessons and reference documents are meant to help every agent that works on it avoid repeating past mistakes and follow established context. Lessons, in particular, were being recorded and displayed but never actually reaching an agent during a run. That's fixed — agents now receive a project's lessons and key documents automatically, and the project's shared notes refresh themselves whenever work merges.

What You Gain

Previously, anything your team had learned and recorded about a project — a gotcha to avoid, a pattern that works well — was visible to people browsing the project, but an agent starting a new run on that same project had no access to it at all. That meant the same kind of mistake could resurface in a later task, even though the lesson from an earlier one had already been written down. Similarly, your project's shared reference document could drift out of sync with what had actually been merged, since agents weren't the ones keeping it current.

Now every agent run starts with the project's recorded lessons already in hand, along with its key reference documents. And the project's main shared reference document now updates itself automatically whenever work merges in, rather than depending on an agent to keep it current.

How It Works

• Every run receives the project's recorded lessons as part of its starting context.
• Key documents marked to "always include" are sent in full, up to the project's set limit; anything beyond that is still available for the agent to open on demand.
• Recent task history is summarized as a quick index, with the five most recent tasks available in full detail.
• Your project's main shared reference document refreshes automatically whenever work merges into the project.
• The planning assistant and AI Chat also draw on the project's overview and lessons, opening a specific document or task's history only when a question needs it.

Where to Find It

This applies automatically to every project — there's nothing to turn on. Manage a project's lessons from its Memory tab and its reference material from Project Documents.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

An agent run needs to know more than just its task — it needs to know what this specific run is for, whether that's reviewing a pull request, reworking a rejected change, or retrying after a failure. A gap in how those run-specific instructions reached the agent meant some runs, especially reviews, were starting with far too little context to do their job. That's fixed: every run type now gets the detail it actually needs.

What You Gain

Previously, a run's specific purpose and context weren't reliably reaching the agent doing the work. The most visible effect was reviews: a reviewing agent could be started with essentially nothing but a task reference, which is part of why reviews so often ended without a real verdict. Rework runs, automatic retries, and coordination steps on larger multi-part tasks had similar gaps, each missing a piece of context that would have helped them succeed the first time.

Now each run type gets exactly what it needs: a review gets the pull request and commit to examine and how to submit its verdict; a rework run gets the previous reviewer's findings; a retry gets a diagnosis of what went wrong last time. Chat and Slack-driven agent work now also reliably receives the message or step that started it.

How It Works

• Reviews receive the pull request, the exact commit, and how to submit a verdict.
• Rework runs receive the previous review's findings, so the agent knows what to fix.
• Retries receive a diagnosis of the failed attempt rather than starting cold.
• Multi-part tasks get the right coordination context at each stage.
• Chat and Slack-driven work now reliably reaches the agent with the message that triggered it.
• Agents are now told how to flag a question that needs a person's attention.
• "View prompt" on a task now shows exactly what the agent was told.

Where to Find It

This applies automatically to every run across every project. Keeping the desktop app and CLI current ensures every run type gets the full benefit.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Merging a pull request previously marked every task mentioned anywhere in it as Done — including tasks it simply referenced, not just the one it was actually for. A merge now closes only the pull request's own task, alongside several other fixes that make long or busy agent runs more reliable.

What You Gain

Before this fix, mentioning a related task in a pull request's description — even just a note like "follow-up to" another task — could cause that other task to be marked Done the moment the pull request merged, whether or not its actual work was finished. For a sub-task whose description names its larger parent task, this could even mark the parent Done before its own work was complete.

Now a merge affects only the one task the pull request is actually for, sharpening the original rule that only a merged pull request closes a task. Tasks it merely mentions stay exactly as they are, still linked to the pull request for reference, with a note recorded so it's clear they were referenced but not closed.

How It Works

• A merge closes only its own task — the one named in the pull request's branch, falling back to its title or description only if the branch doesn't name one.
• Tasks that are only mentioned are left untouched, with a visible note that they were referenced.
• Long-running agent work no longer loses access partway through. Previously, a run's access could expire after an hour even if it was still actively working; it now stays valid for as long as the run is alive, so a long run can still report back when it finishes.
• Cancelling a parent task's run no longer accidentally starts its sub-tasks. The task clearly shows how many sub-tasks are being held, and resuming the parent's work picks them back up.
• Machines running an older app version are flagged, so if a run happens on an outdated machine, that's visible on the task rather than a silent mystery.

Where to Find It

This applies automatically to every project — there's nothing to configure. Keeping the desktop app and CLI up to date ensures you get the full benefit of the reliability improvements.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Quick Actions — the shortcuts you use to prompt an agent from the comment box — now include a dedicated Code Review type, which starts a genuine review of a task's open pull request rather than just asking an agent to comment on it.

What You Gain

Before this, a "review" Quick Action just posted a general prompt to an agent, and whatever came back was a reply in the thread rather than an actual recorded review verdict. If you wanted a real review with a verdict attached to the task, you had to trigger it a different way, which made Quick Actions feel like a shortcut that didn't quite reach the thing you actually wanted.

Now, picking a Code Review action runs a full review: the agent examines the task's open pull request and submits an actual verdict, which moves and labels the task exactly like your project's dedicated review step does. The verdict appears as its own comment at the top of the thread, not buried under a reply, so it's easy to spot.

How It Works

• A new Type field on Quick Actions lets you choose between General (the original prompt-and-reply behavior) and Code Review (a real review with a verdict).
• Trigger it from the comment box's / menu; anything you'd already typed is passed to the reviewer as extra context to focus on.
• It's refused with a clear reason if the task has no open pull request, or if the agent you're asking has already worked on the task itself.
• Your existing "Code Review" Quick Action was switched to this new type automatically; any other Quick Action you use for reviews needs its Type updated under Settings.

Where to Find It

Find and set the Type on any Quick Action under Settings → Quick Actions, then trigger it from the / menu in a task's comment box.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Labels you use on tasks now have a single home: Settings → Labels lists every label across every project, along with how many tasks carry it, so the ones nobody uses anymore are easy to spot and clean up.

What You Gain

Before this, there was no single view of every label your team had ever created — you'd only see which labels existed by browsing individual projects and tasks. Over time that makes it hard to tell which labels are actually in active use and which are leftover clutter nobody reaches for anymore.

Now you can see, at a glance, every label in use across your whole team, how many tasks each one is attached to, and edit or delete the ones that have outlived their purpose — all from one page instead of hunting project by project.

How It Works

• One page lists every label your team uses, across all projects, with a count of tasks on each.
• Edit or delete a label directly from the list.
• The two review labels used by the review workflow are marked as system labels and can't be edited or removed, since they're managed automatically by review verdicts.

Where to Find It

Open Settings → Labels to see and manage every label your team uses.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

A pull request on a project with an assigned reviewer agent could, in a handful of situations, slip through without ever receiving a real review — reviewed against the wrong task, skipped because of an unrelated earlier run, or stuck with no verdict recorded at all. A set of fixes closes each of those gaps, so reviews now reliably start, run against the right work, and report back.

What You Gain

Previously, a few specific situations could leave a pull request effectively unreviewed even though a Review agent was assigned to the project: a pull request could be checked against a different, related task instead of its own; a reviewer could be skipped because it had reviewed an earlier version of the same work; picking a reviewer on a task didn't always start the review right away; and a review that silently failed to finish could leave its pull request waiting indefinitely with no verdict ever recorded. Each of those meant code could end up merged, or sitting unreviewed, without anyone noticing.

Now each of those paths is closed: a pull request's review applies only to its own task, a reviewer is no longer disqualified by unrelated past activity, choosing a reviewer starts the review immediately, and a review with no verdict is retried and then clearly flagged. Pull requests already stuck this way were cleared too.

How It Works

• A pull request's review now applies to its own task only, even when its description happens to mention other related tasks.
• A reviewer is no longer unfairly disqualified by activity that isn't actually its own earlier review of the same work.
• Assigning a reviewer starts the review immediately, rather than waiting for the next change to the code.
• A review that doesn't produce a verdict is retried, then flagged for you instead of sitting pending with no sign anything is wrong.
• Every failed or stuck review is now recorded on the task's own activity history, so you can see exactly what happened and when.

Where to Find It

This applies automatically to every project with an assigned Review agent — there's nothing to configure. The latest desktop app or CLI is recommended to get the full benefit.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.

Summary

Projects can now turn on automatic merging: the moment a pull request's review approves, it's merged on GitHub using the merge method you choose, with no extra click needed. If something prevents the merge, you're told exactly what and why instead of being left to notice a stalled pull request yourself.

What You Gain

Previously, even after a review approved a pull request, someone still had to go merge it — a small but repeated manual step across every approved task. For a team running multiple agents on multiple projects, that adds up to a lot of "it's approved, now go click merge" moments spread across the day.

With auto-merge turned on, an approval is the last step you need to take. Picture a project with continuous integration checks configured: a pull request that passes review and whose checks are still running waits for them before merging; one that fails checks is blocked rather than merged; a project with no checks at all merges right away. Either way, you're freed from remembering to go merge things that have already been approved.

How It Works

• Turn it on per project, under Project → Edit, with a switch and your choice of merge method: squash, merge commit, or rebase.
• Set how long to wait for checks to finish before giving up — two hours by default.
• Merges only the exact commit that was reviewed, so nothing newer sneaks in unreviewed.
• A merge that can't happen is never silent: it's posted on the task, shown on the pull request, and listed wherever you check on things waiting for your attention, along with the reason — a conflict, a branch rule, failed checks, or a missing permission.
• A review you take over yourself never auto-merges, so you stay in control when you step in manually.
• One-time setup: your GitHub App connection needs a few additional permissions approved before auto-merge can work; until then, it reports that clearly instead of failing silently.

Where to Find It

Turn on auto-merge for any project from Project → Edit. It applies only to that project's pull requests going forward.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center with your own team.