Changelog

Summary

Reporting a visual bug usually means a screenshot, a paragraph trying to describe exactly what's wrong, and hoping whoever (or whatever) fixes it understands which element you meant. A new browser extension replaces that with direct annotation: click on the broken element, mark what's wrong, and send it straight into Effigate Command Center as a task ready for an agent to pick up.

What You Gain

Before this, turning something you noticed on a staging or preview page into a task meant describing it in words — which button, which screen, what state it was in — and often attaching a screenshot that still left room for misunderstanding. An agent picking up that task had to interpret a description and a static image to guess what you meant, which slowed things down and sometimes led to the wrong fix.

Now you point at the actual problem. Click the extension's icon on any page you're reviewing, then click an element, select text, or draw a box around an area that's wrong. Add a short note on what's wrong, and submit — the task that lands in your project already has a precise reference to the exact spot you flagged, not just a screenshot and a guess.

How It Works

• Mark it your way. Click a single element, highlight text, group a few related elements, or draw a rough region — whichever fits what you're flagging.
• Freeze the page first when something you want to mark is about to change or disappear, so you can still catch it.
• Add your note and how urgent it is, then pick which project the task should go to.
• A screenshot is captured automatically, so the task carries both your note and the visual context, with no extra steps.
• Sign in once with an emailed code or an access token, and the extension is ready whenever you spot something worth flagging.

Where to Find It

Install the extension in Chrome or Firefox and sign in with your Effigate Command Center account; it works on any page you're reviewing. Each submission becomes a task in the project you choose.

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

Summary

The Effigate Command Center desktop app's Windows release process is now more reliable, after dropping support for 32-bit Windows, a configuration that modern Windows PCs no longer use.

What You Gain

Keeping support for an old 32-bit Windows build added a point of failure to every release, without benefiting the vast majority of users running modern, 64-bit Windows machines. Dropping it means Windows releases of the desktop app go out more smoothly and reliably going forward.

How It Works

• The desktop app for Windows now targets 64-bit machines only, which covers essentially every Windows PC in use today.
• If you're on an older 32-bit Windows machine, you'll need a different device to run the desktop app; the web app continues to work everywhere a browser does.
• No action needed for everyone else — your existing installation and update process are unaffected.

Where to Find It

Download the latest desktop app from your account's download page, same as always.

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

Summary

Every pull request a reviewing agent looks at is supposed to end with a clear verdict — approved, or changes requested. If a review run ended without actually recording one, the pull request used to sit waiting indefinitely, with nothing telling you it needed attention. Reviews now either deliver a real verdict or are flagged for you to see, so nothing silently stalls.

What You Gain

Previously, a review could finish its work, leave comments, and still never formally approve or request changes — and because nothing checked for that, the pull request just sat there looking "in progress" with no indication that it was actually stuck. Someone had to happen to notice the comments, realize no verdict had been recorded, and manually nudge things along. For a team relying on agents to review and ship work while they're focused elsewhere, that gap meant work could quietly wait far longer than it should.

Now, if a review ends without a verdict, it's automatically retried once, and if it still doesn't produce one, it's marked as failed and surfaced where you already check on things that need you. You get a clear signal the moment something needs a second look, rather than discovering it only when you happen to check a pull request yourself.

How It Works

• Every review is held to producing a real verdict — a comment alone no longer counts as a finished review.
• A review that doesn't produce a verdict is retried automatically once, in case it was a one-off hiccup.
• If it still doesn't produce one, it's marked failed and shown to you as something that needs a look, rather than being left open-ended.
• The reviewing instructions were tightened so the agent is clearer about exactly how to submit a verdict, reducing how often this happens in the first place.

Where to Find It

This applies automatically to every project using agent-driven reviews — there's nothing to configure. A flagged review appears wherever you already review items waiting on you.

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

Summary

When a task has a checklist, the agent working on it now sees every item from the moment it starts, and is required to work through the checklist and mark items off before reporting the task finished. Checklists you rely on to track the small steps of a task are now something agents actually act on, not just something you have to tick off by hand afterward.

What You Gain

Before this, a checklist on a task was something mainly you could see — the agent working on the task didn't reliably know it existed, so items could stay unchecked even once every piece of work was actually done. You'd come back to a finished task, look at the checklist, and find it hadn't moved at all, even though the comments and the pull request showed the work was complete. That meant going through tasks yourself to tick items off, or trusting that "finished" really meant everything on the list was covered.

Now the agent receives the checklist up front, and working through it is part of how it finishes the task — so by the time you read the result, the checklist already shows what's done.

How It Works

• Checklists are visible from the start of a run. An agent beginning work on a task now receives the task's checklist along with the rest of the task's details.
• Closing out the checklist is a required step before finishing. Going through the checklist and marking items complete is now part of an agent's standard wrap-up routine, not an easy-to-miss extra instruction.
• Works the same everywhere an agent completes a task — a single task or the last step of a larger piece of work follows the same rule.
• Nothing changes in how you create or edit a checklist. You add and edit checklist items exactly as before; the difference is only in what an agent does with them before it's done.

Where to Find It

This applies automatically to every task with a checklist, on every project — there's nothing to turn on. Add or edit a checklist from any task's detail view, same as always.

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

Summary

The workspace timezone picker now shows the modern name for your time zone — for example the current name for a region instead of an older one that technically refers to the same time zone but has since fallen out of everyday use. Nothing about the time itself changes; only the label you pick from is clearer.

What You Gain

Previously, the timezone picker listed some time zones under their decades-old names, which can be unfamiliar even though they point to the exact same time as the name people actually use today. That made it easy to second-guess whether you'd picked the right one for your team.

Now the picker shows the modern, familiar name for each time zone instead. If your workspace had already picked one of the older names, it still matches correctly to its renamed entry — there's nothing to redo.

How It Works

• Modern names throughout the picker. Each time zone list entry shows its current, commonly used name.
• Existing selections still match. A workspace already set to an older name is automatically recognized as the same, modern option.
• No change to the actual time. This only affects the label you see; your workspace's clocks and schedules are unaffected.

Where to Find It

Open your workspace settings and the timezone picker to see the updated names — this is already live for every workspace, with nothing to reconfigure.

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

Summary

A project's Sprints tab now has a List/Board toggle. Board groups every task across every sprint — plus anything unscheduled — into status columns you can drag cards between, the same way the main task board already works, while List keeps the familiar collapsible-sections layout you're used to.

What You Gain

Until now, the Sprints tab only offered one layout: sprints as collapsible sections with tasks listed as rows inside them. That's a good fit for reviewing a sprint's full task list, but it made it harder to see, at a glance, how work was moving across statuses within and across sprints.

Now a Board view sits right next to List. Switch to it and every task — across every sprint, plus anything not yet scheduled into one — appears in status columns, exactly like the main Kanban board. Drag a card into a new column and its status changes immediately, the same way it does from the main board. Because Board groups by status rather than by sprint, each card carries a small sprint badge so you can still tell which sprint — or none — it belongs to.

How It Works

• Toggle next to Add Sprint. A List/Board switch sits alongside the button you already use to add a sprint.
• Board groups across every sprint. Status columns pull in tasks from every sprint plus anything unscheduled, all in one view.
• Drag-and-drop changes status. Moving a card between columns updates its status the same way the main board does.
• Sprint badges keep context visible. Each card shows which sprint it's in, since Board groups by status rather than by sprint.
• Your choice is remembered. The app remembers whether you last used List or Board and opens the same view next time.

Where to Find It

Open any project's Sprints tab and use the new toggle next to Add Sprint — available to every account today, with nothing to configure.

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

Summary

The Project Brain tab now separates the project's stable overview from its Merged Task Log, and lists each merged task as its own collapsed row — identifier and merge date, newest first — that expands to the full entry only when you click it. As a project accumulates more merged work, the tab stays easy to scan instead of growing into one long page.

What You Gain

As a project builds up a longer history of merged tasks, the Brain tab used to render everything as a single, continuous document — the overview and every individual task's memory entry stretched end to end. Finding one specific task's entry, or just the project's current overview, meant scrolling through everything else first.

Now the overview sits on its own at the top, and every merged task gets a single collapsed row beneath it. Scanning the log for a particular task is now a matter of glancing down a short list of identifiers and dates, rather than searching through a long document for the right section.

How It Works

• The overview is separated from the log. The project's current overview renders on its own, no longer mixed in with individual task entries.
• Each merged task is one row. The Merged Task Log lists one row per task, showing its identifier and merge date.
• Newest first. Rows are ordered with the most recently merged task at the top.
• Click to expand. Click a row to see that task's full memory entry; click again to collapse it.

Where to Find It

Open any project's Brain tab to see the new layout — it applies automatically to every project with merged history, with nothing to turn on.

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

Summary

The mobile app's Agent Office and the iOS home-screen widget now correctly show which agents are actively working, matching what the desktop app has shown all along. Previously, both could say no agent was working even while one genuinely was.

What You Gain

Before this fix, the desktop Office correctly showed an agent mid-task, but the mobile Agent Office's Work Area said no agents were currently working, and the home-screen widget echoed the same "nobody right now" message — even during an active run. The two surfaces were reading the same underlying activity differently, and mobile consistently lost that comparison.

Now mobile draws on the same signal the desktop app already relied on, so an agent's status is shown as working whenever it genuinely has an active run on a connected device. A run that's stuck or waiting on a disconnected device correctly doesn't count as working, so the status you see reflects what's actually happening, not a stale snapshot.

How It Works

• Mobile Work Area matches desktop. The mobile Agent Office now shows an agent as working under the same conditions the desktop app already used.
• Home-screen widget matches too. The iOS widget reflects the same corrected status.
• Presence indicators are consistent. Agent picker dots showing "online while working" now reflect this same, corrected status everywhere they appear.
• Updates arrive live. Mobile already refreshes agent activity in real time, so the corrected status appears the moment a run starts — no app update needed.

Where to Find It

This fix is already live for every account on the mobile app's Agent Office and home-screen widget, with nothing to turn on.

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

Summary

Typing a checklist item into the new-task window and pressing Enter or clicking add now keeps that item, ready to be saved along with the rest of the task. Previously, doing this before the task existed cleared the input and added nothing, with no indication anything had gone wrong.

What You Gain

Before this fix, adding a checklist item while still filling out a brand-new task simply didn't work — the input cleared as if it had been added, but nothing was actually saved, because the task didn't exist yet to save it against. It was easy to type out a short checklist while setting up a task, move on, and only later discover none of it had actually been kept.

Now checklist items typed before the task is created are held right there in the new-task window, fully editable — check them off, rename them, or remove them — the same as any other part of the form. Everything you've entered, including the checklist, is created together in one step when you click Create task, so there's no moment where a half-finished task exists without the checklist you just typed.

How It Works

• Checklist items stay in the new-task window. Add, check, rename, or remove items before the task is even created.
• Everything saves together. Clicking Create task saves the task and its checklist in one step.
• No half-created tasks. If you close the window before creating the task, nothing is left behind partially saved.

Where to Find It

This applies automatically the next time you open the new-task window on Effigate Command Center — 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 tasks.

Summary

The AI Assistant — both the web widget and the mobile app's Task AI Chat — now proposes a set of tasks that matches the number of genuinely separate things you described, instead of expanding a simple request into a longer list of invented process steps. Describe three issues, and you get proposals for up to three tasks, not seven.

What You Gain

Previously, describing a handful of related issues to the AI Assistant could come back with a much longer, over-decomposed proposal: an umbrella parent task that wasn't asked for, separate tasks for "regression coverage" or "verification" that belong inside a task's own checklist rather than as standalone work, and occasionally an entire extra feature nobody requested. Reviewing and trimming a proposal like that took longer than it should have, and it was easy to accept more scope than you meant to.

Now the Assistant sizes its proposal to the number of separable deliverables you actually described, keeps testing and verification steps inside each task's checklist instead of spinning them out as their own tasks, and only mentions optional extra ideas in passing rather than proposing them as work. A flat list of tasks is the default; a parent task with its own sub-tasks is only proposed when one deliverable genuinely depends on pieces that build on each other.

How It Works

• Task count matches your request. Describe three distinct issues and the Assistant proposes up to three tasks — not an inflated list.
• Checklists absorb process steps. Testing, QA, and verification steps live inside each task's own checklist rather than becoming separate tasks.
• No uninvited scope. Ideas beyond what you asked for are mentioned in the Assistant's reply, not slipped into the proposal as tasks.
• Parent/sub-task structure only when it's warranted. This shape is reserved for one large deliverable whose pieces genuinely depend on each other, not used as a default.

Where to Find It

This applies automatically the next time you use the AI Assistant on web or the Task AI Chat on mobile — 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 backlog.

Summary

Fixed a rare timing issue where a failed agent run could get permanently stuck showing as "waiting for a local directory," which silently blocked every future run for that same agent and task — including a new run triggered by @mentioning the agent after the original problem was already fixed.

What You Gain

In a small number of cases, a run that had already failed could, moments later, be incorrectly marked as still waiting on a local directory, because of a timing gap between a run reporting its status and the server recording it. Since that waiting state is treated as "still in progress," every later attempt to run that same agent on that same task — even one you triggered yourself after fixing the underlying problem — was silently skipped, with no run ever actually starting and no clear sign of why.

That's now closed from three directions: the server no longer lets a run that already finished get flipped back into a waiting state, a background check that already runs regularly now actively finds and recovers any run stuck this way, and the run itself now waits for its own status update to fully land before it's allowed to record a failure. Together, these mean a task can no longer get wedged behind a run that looks active but isn't.

How It Works

• Finished runs can't be reopened into a wait state. Once a run has completed, failed, or been cancelled, it can no longer be rewritten back to waiting.
• Stuck runs are found and recovered automatically. A regular background check now actively identifies and clears any run left behind in this stuck state.
• Status updates are ordered correctly. A run now confirms its own status has landed before reporting a later result, removing the timing gap that caused this.
• @mentioning an agent reliably starts a new run. A follow-up run on the same task and agent is no longer silently skipped because of a leftover stuck state.

Where to Find It

This fix applies automatically to every project and agent — there's nothing to configure, and any task that was previously stuck this way will recover on its own.

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

Summary

Task descriptions now show your actual written description everywhere a task appears — the mobile app, the CLI, and the API — instead of occasionally showing the much longer internal brief an agent works from. Alongside that fix, a new View Prompt option in the task menu lets you see that internal brief on purpose, whenever you want to.

What You Gain

Previously, some ways of reading a task's description returned the full internal brief an agent uses to work on it — project context, team information, and implementation notes — instead of the shorter description you actually wrote. On mobile and in the CLI, that showed up as a long wall of text that didn't match what you saw on the web. In a small number of cases, a tool that read a task this way and saved it back ended up overwriting the real description with that longer text; any task affected this way has already had its original description restored.

Now every way of reading a task — web, mobile, CLI, and the API — consistently returns the description you wrote, not the agent's working brief. And since that fuller brief is still genuinely useful to see on purpose, it's now available deliberately: a View Prompt option in the task's menu shows it in a readable, formatted view, exactly as an agent would receive it when picking up the task.

How It Works

• Descriptions are consistent everywhere. Web, mobile, the CLI, and the API all show the same description you wrote for a task.
• View Prompt shows the agent's full brief on demand. Open it from the task's menu to see the complete context an agent uses to work on that task.
• Already-affected tasks were restored. The small number of tasks whose descriptions were previously overwritten have had their original text put back.

Where to Find It

View Prompt is in the task's ⋯ menu inside the task window, available on every Effigate Command Center account. The description fix is already live everywhere, with nothing to configure.

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

Summary

Project Brain's Merged Task Log previously showed a number of already-merged tasks without the memory entry agents write when their work lands. Those entries weren't actually lost — a server-side gap kept them from being collected — and they've now been recovered and filled back into the log, with better diagnostics in place so a gap like it is caught immediately next time.

What You Gain

Before this fix, a merged task could show up in the Merged Task Log with no memory entry attached, even though the agent had written one as part of finishing the work. Nothing about this pointed to the real cause, so it read as though agents simply weren't recording what they learned — when in fact the entries existed, they just weren't being picked up.

Now that gap is closed, and the memory entries for the tasks it affected have been assembled and added back into Project Brain, so the project's history reflects what agents actually recorded. Going forward, a configuration gap like this is caught and reported immediately rather than quietly looking like missing agent output.

How It Works

• Past gaps are already filled in. The memory entries affected by this issue have been recovered and added to the Merged Task Log — no action is needed from you.
• Future issues surface clearly. If a similar configuration problem ever recurs, it's now reported as a distinct, specific issue instead of looking like an empty memory entry.
• Nothing to change in how your agents work. Agents continue writing their memory entries exactly as before; this only fixes how reliably those entries reach Project Brain.

Where to Find It

Open a project's Brain tab and check the Merged Task Log — recovered entries are already there for every affected account, with nothing to configure.

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

Summary

Fixed an error in the account check that runs immediately after signing in — the very first thing the mobile app, the desktop CLI's status check, and the web app all do to confirm who you are. Signing in itself worked, but this follow-up step could fail, which meant the app couldn't finish loading your account afterward.

What You Gain

Previously, this account check could return an error for every client that called it — the mobile app on launch, the CLI's status command, and the web app alike — even though your credentials were correct. From your side, it looked like sign-in itself was broken, when the real issue was in the step that loads your account details right after.

The underlying cause was narrow and specific to how your profile photo was looked up during that check, and it's now fixed at the source. On top of that, the lookup for your profile photo no longer brings down the whole account check if it runs into any problem — it simply shows no photo and reports the issue, so one small failure can't block you from signing in and using your account.

How It Works

• The account check now completes reliably. Signing in and loading your account on any client — mobile, desktop CLI, or web — no longer fails on this step.
• A photo lookup problem no longer blocks sign-in. If your profile photo can't be loaded for any reason, the rest of your account loads normally and the issue is reported separately.
• No action needed from you. This is a server-side fix; there's nothing to update or reconfigure.

Where to Find It

This fix is already live for every Effigate Command Center account across the mobile app, desktop CLI, and web app.

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

Summary

Claiming a task that was assigned to an agent now fully takes it over. Previously, claiming left the agent's assignment in place alongside yours, so the task kept behaving as if the agent still owned it even after you'd claimed it.

What You Gain

Before this fix, "claiming" an agent-assigned task added you as a member assignee but didn't remove the agent — so the task ended up with both an agent and a person assigned at once, an inconsistent state that every screen then had to interpret on its own. In practice, the task kept showing and behaving as the agent's, so claiming it looked like it had quietly done nothing.

Now claiming is a genuine take-over: assigning yourself to a task that was previously an agent's clears that agent assignment, on the board, in the task window, and on the web, so there's only ever one clear owner. Existing tasks that were left in that mixed state have also been cleaned up automatically to match what you were already seeing on screen.

How It Works

• Claiming replaces the agent, every time. Whichever screen you claim from, the agent assignment is cleared and you become the task's owner.
• Creating or editing a task follows the same rule. If a task is set to both a person and an agent at once, the agent takes precedence consistently, so what's stored always matches what's displayed.
• No cleanup needed on your side. Tasks that were previously stuck in the mixed state have already been corrected.

Where to Find It

This takes effect automatically wherever you claim a task — the board, the task window, or 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 team.

Summary

You can now upload a profile picture from the web app, with a familiar adjust step — drag to reposition, zoom with the slider or your scroll wheel, and a circular preview of exactly what will be saved. Once set, that same photo now shows consistently everywhere you appear across Effigate Command Center: the top navigation, your profile page, task comments, and the mobile app.

What You Gain

Until now, there was no way to add a profile picture from the web app at all — your profile was limited to initials or a placeholder wherever your identity showed up, making it harder to tell teammates apart at a glance across busy boards and comment threads.

Now the profile page includes a straightforward upload-and-adjust step: pick a photo, drag it into position, zoom until it looks right, and save. The result is the same picture everywhere you show up — on a busy board or comment thread with several teammates and agents active at once, it's immediately obvious who said what, instead of scanning initials to work it out.

This also resolves two separate issues that had made the mobile app's own photo support look unreliable: an account-loading error that could prevent your photo from showing at all, and a server configuration issue that could make an uploaded photo's image link fail to resolve. Neither needs any action from you — uploaded photos now display correctly regardless of either underlying cause.

How It Works

• Upload and adjust on the web. Open your profile page, choose a photo, then drag to reposition and use the zoom slider or your scroll wheel to frame it inside the circular preview.
• One photo, shown everywhere. The same picture appears in the top navigation, your profile page, task comments, and the mobile app's Me, Edit Profile, and comment screens.
• Uploads display reliably. Photo links now resolve correctly on every account, closing out the display issues some mobile users previously saw.

Where to Find It

Open your profile page on the Effigate Command Center web app to upload or change your photo; it then appears automatically everywhere on web and mobile. Available to every account today, with no settings to turn on.

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

Summary

Signing back in on the mobile app — after a fresh install, clearing storage, or simply logging in again on the same device — now closes out your previous session for that device before starting the new one. Your account no longer accumulates old, still-active sessions every time you sign in again on the same phone.

What You Gain

Previously, each time you re-authenticated on a device, the app quietly kept the old session alive alongside the new one instead of replacing it. Over repeated sign-ins on the same phone, that meant a growing number of sessions for a single device, all still technically valid.

Now, verifying your code on sign-in retires every other active session already registered to that same device before issuing the new one. Signing in again behaves the way you'd expect: it replaces your last session rather than stacking a new one on top of it.

How It Works

• Re-authenticating on a device clears its older sessions first. Confirming your one-time code revokes any other active session already tied to that device name.
• One device, one active session. You no longer end up with several live sessions for the same phone after repeated sign-ins.
• No extra steps. This happens automatically as part of signing in — there's nothing to review or clean up yourself.

Where to Find It

This takes effect automatically the next time you sign in on the Effigate Command Center mobile app — there's no setting to change.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center on your team's next project.

Summary

Live updates across the Effigate Command Center mobile app — task detail, the project board, chats, agent run activity, and the Agent Office — now arrive the moment something changes, instead of waiting for the screen's next automatic refresh. What you see on your phone now matches what's actually happening in real time.

What You Gain

Before this fix, mobile screens that are supposed to update live were quietly relying on their fallback instead: a periodic refresh timer, or whatever reloaded when you reopened the app. A teammate moving a task, an agent starting or finishing a run, or a new chat message would all eventually show up, but only once the screen's timer caught up — not the instant it happened. On a busy project, that lag made the app feel like it was always a step behind the web version.

Picture watching an agent work on a task from your phone: previously, you might see it listed as "idle" for a stretch after it had already started, simply because the live signal that should have updated the screen never reached it. Now the same signal that updates the web app the instant something changes reaches the mobile app too, so task detail, the board, chats, and the Agent Office all reflect what's happening as it happens.

How It Works

• Task detail updates live. Status, comments, and changes from teammates or agents appear on the task screen immediately, not on the next refresh.
• The project board updates live. Cards move and change status on your phone as soon as they do anywhere else.
• Chats update live. New messages from an agent or a teammate arrive the moment they're sent.
• Agent run activity updates live. The Agent Office and run transcripts reflect a run starting, progressing, or finishing without you needing to pull to refresh.
• No action needed. This is a behind-the-scenes fix to how the app listens for updates; nothing changes about how you use it.

Where to Find It

This is already active across the Effigate Command Center mobile app for every account — there's nothing to turn on.

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

Summary

Two reliability fixes for the mobile app: the home-screen widget now confirms its data actually saved before refreshing, instead of assuming it worked, and the very first request the app makes after you open it now retries automatically if it hits a brief hiccup rather than failing outright.

What You Gain

Previously, if the home-screen widget's update didn't fully save for any reason, the widget had no way of knowing — it would simply show stale information with no indication anything was wrong, and no way for you to tell a working widget from a stuck one. Separately, the first call the app makes on launch — loading your account — occasionally failed outright during brief periods of high load, which meant the app could fail to open properly for no reason you could diagnose.

Now the widget double-checks its own update immediately after saving it, so a failed update is caught and retried rather than silently shown as current. And the app's launch step automatically retries once if it hits a brief, passing failure, so a momentary blip no longer stops you from getting into the app.

How It Works

• Widgets verify their own updates. After refreshing your home-screen widget, the app confirms the new data actually saved before considering the update complete.
• Sign-in recovers from brief hiccups. The app's first request after launch retries automatically if it hits a short-lived failure, instead of giving up immediately.
• Nothing to configure. Both fixes run automatically in the background.

Where to Find It

This applies automatically to every Effigate Command Center mobile account — no update to your settings is needed.

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

Summary

The Decision Queue — the ranked list of everything currently waiting on a person's attention — was previously only reachable from the web app itself. It's now available over the API too, using exactly the same logic, so no two views of your Decisions can disagree.

What You Gain

Before this, if you wanted your decision queue anywhere other than the Effigate Command Center web page, there wasn't a way to get it. Now it's available over the API, scoped and permissioned the same way the web page always has been.

This is the same foundation the mobile app's own Decisions screen is built on, so whether you check your decision queue on the web, on mobile, or build your own integration against the API, you're always looking at the same list.

How It Works

• Fetch your decision queue as structured data, matching exactly what the web page shows.
• Get your current count, useful for badge-style indicators in your own tools.
• Clearing an item works the same way it already did.

Where to Find It

Available now for every account through the API; see your account's API documentation for the exact endpoints.

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

Summary

If you belong to more than one workspace, Effigate Command Center used to treat the first one you ever joined as "the" workspace for almost everything, with no way to change it. You can now switch your active workspace, and the whole product follows that choice.

What You Gain

Before this, dashboards, autopilot settings, skills, connected machines, labels, and integrations all quietly used whichever workspace you joined first — there was simply no control to change that, even if your day-to-day work had since moved to a different one. If you joined a second workspace later, most of the product kept acting as though you only had the first.

Now you can activate whichever workspace you're currently working in, and every one of those areas follows the same choice. If you split your time between two workspaces, switching your active one now actually changes what you see across the board, not just in the one or two places that already let you pick a project explicitly.

How It Works

• Activate any workspace you belong to from the workspace switcher.
• Everything follows it. Dashboards, autopilot, skills, connected machines, labels, and integrations all reflect whichever workspace is currently active.
• Nothing changes if you only have one workspace, or if you never switch — your first membership stays the default.

Where to Find It

This is live now for every account with more than one workspace. Use the workspace switcher to pick which one is active.

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

Summary

The list of workspaces you belong to now reports which one is currently active, giving workspace switchers a reliable way to highlight the right one.

What You Gain

Before this, there was no direct way to tell which workspace was active from the list itself, so a switcher could only guess based on order. Now it knows for certain.

How It Works

Any workspace switcher built on this information can now show your active workspace accurately, matching what the rest of the product already treats as current.

Where to Find It

This is live now behind the scenes, with nothing to turn on.

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

Summary

Opening a task link used to always land in your phone's browser, even if you had the Effigate Command Center app installed. On iOS, those links now open straight into the app itself.

What You Gain

Before this, tapping a task link shared by a teammate — in a message, an email, or a notification — opened a mobile browser tab, which meant an extra step logging in or navigating to find the actual task, even with the app already installed.

Now, on iOS, tapping a task link opens the app directly to that task, skipping the browser entirely. If a teammate shares a task link with you, you land exactly where you need to be with one tap.

How It Works

• iOS is fully set up today: any task link opens directly in the app if it's installed.
• Android support is on its way: the groundwork is in place and will switch on once a remaining setup step is completed, with no update needed on your end when it does.

Where to Find It

Live now on iOS for everyone with the app installed — no setting to turn on. Android will follow.

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

Summary

Pinning a task looked like it worked, but nothing was actually being saved behind the scenes — a pin would quietly vanish the next time you checked. Pinning is now a real, saved action.

What You Gain

Before this fix, pinning a task appeared to succeed in the moment, but there was no real record of it anywhere. Come back later, and the pin would simply be gone, with no indication anything had gone wrong. If you'd gotten in the habit of pinning a handful of tasks you wanted to keep close at hand, you'd have found them unpinned again the next time you looked.

Now, pinning a task saves for real, scoped to your own account. You can pin a task, see your pins with their current title and status, reorder them, and unpin anything you no longer need to keep handy.

How It Works

• Pin any task you want quick access to.
• See your pins in one place, each showing the task's current title and status.
• Reorder your pins to put what matters most at the top.
• Unpin a task the moment you no longer need it pinned.

This also lays the groundwork for a dedicated Pinned section on the mobile app's Home screen, which will show your pinned tasks directly.

Where to Find It

Pinning is live now wherever you could already pin a task — it just works correctly now, with nothing new to turn on.

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

Summary

The mobile app's Appearance settings now include a Color Theme picker alongside the existing Light, Dark, and Auto options, so you're no longer stuck with one accent color.

What You Gain

Previously, the mobile app's accent color — the color used for buttons, links, and selected states — was fixed to a single default with no way to change it. Now you can pick the look that feels like yours.

Choose from the original default or three alternatives: Mint, Pink, and Blue. Whichever you pick applies everywhere the accent color shows up across the app — buttons, links, selection states, and the active tab — and is remembered the next time you open the app.

How It Works

• Open Appearance settings in the mobile app.
• Pick a Color Theme: Default, Mint, Pink, or Blue.
• It applies everywhere the accent color is used, and sticks across app launches.

Where to Find It

Available now in the mobile app's Appearance settings for every account.

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

Summary

A handful of workspace actions — inviting someone, revoking an invitation, listing pending invitations, and switching workspaces from the desktop app — could fail with a confusing "not found" error instead of working. Those are now fixed.

What You Gain

Before this, these specific actions didn't always recognize a workspace correctly, which meant an invite or a desktop workspace switch could simply fail for no clear reason, even though the workspace itself was fine.

Now all of these actions resolve a workspace the same reliable way, so inviting a teammate, revoking access, checking pending invitations, and switching workspaces from the desktop app's commands all work as expected.

How It Works

• Invitations — sending, revoking, and listing pending ones now work consistently.
• Desktop workspace commands — switching your active workspace from the desktop app's command-line tools no longer errors with "workspace not found."

Where to Find It

Live now for everyone, with nothing to turn on.

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

Summary

The mobile app now offers three widgets, available on both iOS and Android, that put your usage and agent activity right on your Home Screen — and, on iOS, on your Lock Screen too — without opening the app.

What You Gain

Before this, checking your usage or seeing whether your agents were active meant opening the app and navigating to the right screen every time. For anyone who checks in on their agents throughout the day, that's a small but repeated bit of friction.

Now three widgets put that information one glance away. Monthly Tokens shows a six-month usage bar chart so you can spot trends at a glance. Usage This Month gives you tokens, cost, task count, and runtime for the current month without opening anything. Agent Status shows how many agents are actively working right now — and on iOS, this one is also available as a Lock Screen widget, so you can check it without even unlocking your phone.

Picture glancing at your phone between meetings: your Lock Screen already tells you three agents are currently working, without a single tap.

How It Works

• Monthly Tokens widget — a six-month bar chart of your token usage, right on your Home Screen.
• Usage This Month widget — tokens, cost, tasks completed, and runtime for the current month, at a glance.
• Agent Status widget — how many agents are actively working right now; also available as an iOS Lock Screen widget.
• Kept in sync while you use the app — widgets refresh when you open the app, when it resumes from the background, and every 30 minutes while it's active. There's no independent background refresh, so a widget reflects the last time the app was open rather than a truly continuous live feed.

Where to Find It

Available now on both iOS and Android. Add any of the three widgets from your phone's own widget picker, the same way you'd add a widget from any other app; the Agent Status widget is also available as an iOS Lock Screen widget.

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

Summary

Verifying a sign-in code could, on some accounts, fail with a server error instead of completing — affecting the mobile app, the web-based CLI sign-in flow, and MCP token exchange alike. That's now fixed.

What You Gain

Before the fix, some sign-in attempts would stall on the verification step with a generic error, forcing a retry with no clear explanation of what went wrong. It wasn't tied to anything you did — a missing piece of account bookkeeping during the sign-in step meant it occasionally failed outright.

Now that step completes reliably every time, across every way you can sign in with a code.

How It Works

All three code-verification paths — the mobile app, the web CLI flow, and MCP token exchange — mint your session the same corrected way, so a sign-in that used to fail now completes normally.

Where to Find It

Live now for everyone, with nothing to change on your end. If you'd previously hit this error, signing in again should now work without issue.

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

Summary

A live transcript update could silently fail to appear when the step it described — a large file edit, for example — carried an unusually large amount of data. That's fixed.

What You Gain

Before the fix, a handful of larger steps in an agent's run could go missing from the live transcript view, even though the agent had completed them. Now every step shows up live regardless of size.

How It Works

Large tool-call data is now shortened for the live view the same way other large content already was, so every step reaches the transcript. The complete, untruncated detail remains available afterward either way.

Where to Find It

Live now for everyone, with nothing to turn on.

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

Summary

A screenshot attached directly to a comment — using the comment box's own attachment button, not the task's main Attachments panel — failed to preview in the browser. That's fixed, and a related confusing error for agents fetching these files has been cleared up too.

What You Gain

Before the fix, a screenshot dropped straight into a comment would fail to display as an image preview, regardless of where the file was stored. Now it previews correctly every time, whichever comment it's attached to.

Separately, an agent trying to retrieve one of these comment screenshots through the standard file command used to get a bare, unhelpful error. That error now points toward the right way to fetch it, so the agent can recover and continue instead of getting stuck.

How It Works

• Comment screenshots preview correctly in the browser, the same as any other attachment.
• A clearer error for agents when fetching a comment attachment the wrong way, pointing them to the right command instead of a dead end.

Where to Find It

Live now for everyone, with nothing to turn on.

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

Summary

Looking up the members of a workspace could, in some cases, come back empty or show the wrong people instead of the actual member list. That's fixed.

What You Gain

Before the fix, this inconsistency meant a workspace's member list wasn't always trustworthy. It now resolves the same way, reliably, every time.

How It Works

Workspace member lookups now use the same consistent method as the rest of the product, so the member list you see always matches the actual workspace.

Where to Find It

Live now for everyone, with nothing to turn on.

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

Summary

The mobile app now has a dedicated dictation button next to its existing voice-note recorder, letting you speak directly into a text field instead of recording a separate audio file. Words appear live as you talk, and nothing leaves your phone to make it work.

What You Gain

Before this, voice input on mobile meant recording a voice note as a separate attachment — useful for a quick message, but not for actually writing out a task description or a comment. If you wanted to dictate the body of a task, your only option was your phone's own keyboard dictation, which isn't always convenient mid-workflow.

Now dictation is built directly into the places you'd want it: task descriptions, comments, and Task AI Chat. Tap the new mic button and start talking — your words appear in the field as you speak, the same familiar feel as your keyboard's own dictation, but without leaving the app's text fields. Picture dictating a task description while walking between meetings: tap the mic, describe what needs doing, and it's typed out and ready to save by the time you're back at your desk.

How It Works

• A dedicated mic button sits next to the existing voice-note recorder in task descriptions, comments, and Task AI Chat.
• Live transcription — words appear in the field as you speak, not after you finish.
• On-device speech recognition — your dictation is processed on your phone, not sent elsewhere to be transcribed.
• Choose your language from a new Speech settings screen, listing every language installed on your device.

Where to Find It

Available now in the mobile app wherever you can type a task description, comment, or Task AI Chat message — just tap the new mic icon.

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

Summary

Deleting a task from its detail view now removes it from the Sprints tab right away, instead of leaving a stale row behind until you reload the page. Each row on the Sprints tab also now has its own delete button.

What You Gain

Previously, deleting a task while its detail view was open wouldn't tell the Sprints tab anything had changed — the task's row would linger there, looking very much alive, until you refreshed the page. That could easily leave you second-guessing whether the delete actually went through.

Now the Sprints tab updates the moment a task is deleted, whether that task lived inside a sprint or in Unscheduled. On top of that, you no longer need to open the full task detail just to delete something from the Sprints tab — a delete button sits right on each row, with the same "type delete me" confirmation used anywhere deletion matters.

How It Works

• Instant removal. Deleting a task clears its row from the Sprints tab immediately, no reload needed.
• Delete button on every row. Each task row on the Sprints tab now has its own delete action next to Edit.
• Same safety check. Deleting from here uses the same confirmation as deleting anywhere else, so it's never accidental.

Where to Find It

Live now on the Sprints tab for everyone, with nothing to turn on.

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

Summary

The mobile app can now show your unread inbox count directly on its home-screen icon, and a new Clear Cache button gives you a quick way to wipe anything stored on your device if something looks out of date.

What You Gain

Previously there was no way to see how many unread items were waiting for you without opening the app, and no simple way to clear locally cached data if the app ever showed something stale.

Now a new App Badge toggle in Notification settings keeps your unread inbox count on the app icon, updated automatically and cleared the moment you sign out. It's off by default and only asks for the notification permission it needs once you turn it on. Separately, a new Clear Cache action on the Me tab lets you wipe everything the app has stored locally in one tap, useful if something on screen ever looks out of sync.

How It Works

• App Badge toggle in Notification settings — turn it on to see your unread count on the home-screen icon.
• Stays current automatically, and clears itself when you sign out.
• Clear Cache on the Me tab wipes on-device cached data instantly, no sign-out required.

Where to Find It

Both are available now in the mobile app: App Badge under Notification settings (off by default), and Clear Cache under the Me tab.

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

Summary

The mobile app's comment composer, AI Chat composer, and new-task description field have been redesigned for a clearer, more consistent layout, alongside a fix for a display bug that could make an empty field look oddly oversized.

What You Gain

Before this, an empty comment or description field could visually balloon to several lines tall, making the composer look like a floating, misplaced bubble rather than a proper input. On the task detail screen specifically, the comment composer could also overlap the Comments section above it, including the "No comments yet" message, hiding content behind the keyboard area.

Both issues are now fixed, and all three composers share a clearer design: a labeled section with a single bordered box holding the text area and its icon row together, instead of a loose pill squeezed between icons.

How It Works

• Consistent sizing — an empty field now stays compact instead of stretching to several lines.
• Clearer layout — comment, AI Chat, and description fields share one labeled, bordered design.
• No more overlap — the comment composer on the task detail screen no longer covers content above it.

Where to Find It

Live now in the mobile app for everyone, with nothing to turn on.

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

Summary

Every task in Effigate Command Center has a short ID, like a reference number, that makes it easy to point to a specific piece of work. That ID now appears next to the task title in both your Inbox and your Decisions list, so you can tell at a glance which task a notification or a waiting decision belongs to.

What You Gain

Previously, the task ID only reliably showed up in a couple of places. Scanning a busy Inbox full of similarly titled notifications, or a Decisions list with several items on related work, meant opening each one just to confirm which exact task it referred to. For a team juggling many similarly named tasks, that's a few extra clicks every single time.

Now the ID rides alongside the title everywhere a task shows up in these two views, including when a task's details open outside the main Board. If you're scanning your Inbox after a busy day and see three notifications about tasks that all start with "Update," the ID next to each one tells you immediately which is which, without opening a single one.

How It Works

• Inbox rows now show the task ID next to the title on every notification.
• Decisions shows the same ID treatment it always had, now matched everywhere else a task's header appears.
• Task detail headers show the ID consistently, whether you opened the task from the Board, from Decisions, or from Inbox.

Where to Find It

This is live now for everyone — there's nothing to turn on. Open your Inbox or Decisions list to see it.

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

Summary

Clearing certain run-related items out of your Decisions list — specifically ones flagged as escalated or waiting on a local directory — could fail with an error instead of clearing. That's fixed.

What You Gain

Before the fix, trying to dismiss one of these items from Decisions could throw an error and leave it stuck in your queue, even though you'd already handled it. Now the clear action completes normally every time.

How It Works

Clearing any item from Decisions, including escalated or waiting-on-directory items, now works reliably and removes it from the list as expected.

Where to Find It

This is live now for everyone, with nothing to turn on.

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

One digest instead of forty notifications

At the end of each day, Autopilot compiles everything your agents did into a single roll-up: shipped work, blocked runs, and anything waiting on your review — grouped by project so scanning takes seconds.

Summary

Watching an agent work in Effigate Command Center used to mean looking at a frozen snapshot: the transcript showed whatever had happened by the moment you opened it, and you had to close and reopen it to see anything new. Transcripts now update live, on the web, in the mobile app, and in the desktop app's Office view, so you can follow an agent's work step by step as it happens.

What You Gain

Previously, if you opened a running agent's transcript to check on progress, you were looking at a point-in-time capture. A still-working agent might complete several more steps while you watched, and none of them would appear until you closed the view and reopened it — or, on the desktop app, the panel could simply stay blank. For anyone keeping an eye on a long-running task, that meant a lot of manual refreshing just to see what's actually happening.

Now every step an agent takes appears the moment it happens. Picture checking in on an agent mid-task: instead of a static list that ends mid-sentence, you watch each new action land in real time — a file being edited, a command running, a message being written — the same way you'd watch a teammate work over your shoulder. Tool calls stay collapsed to a short one-line summary by default, so the view stays readable even on a busy run; tap or click any one of them to expand the full detail.

Desktop's Office view gets a specific improvement here too: clicking on an agent whose most recent work ran on a different machine used to show an empty panel more often than not. It now reaches the same live source mobile and web use, so an agent's transcript shows up correctly regardless of which machine actually ran it.

How It Works

• Live by default. Open a transcript from a task's execution history, from an agent's screen on mobile, or from its desk in the desktop app's Office view — it now fills in as the agent works, with no refresh needed.
• Collapsed tool calls, full detail on demand. Each tool call shows as a short summary; tap or click to see the complete input and output.
• Works across machines. An agent's transcript streams correctly in the desktop Office view even when the agent's work is running on a teammate's computer, not just your own.
• No more stuck loading state. The web transcript view no longer gets stuck showing "Loading transcript…" when you reopen it quickly after closing it.

Where to Find It

This is live now for everyone on web, mobile, and desktop, with nothing to turn on. Open any agent run's transcript to see it update as the agent works.

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 includes a Customer Portal: a separate, branded space where you can share the progress of a project with your own customers, carrying your logo and colors instead of ours. You choose exactly what they see, task by task, and nothing is visible until you turn it on.

What You Gain

Before this, keeping a customer updated on project progress meant exporting a status update by hand, or giving them raw access to your internal board, comments and all. Neither is a great option: one is slow, the other hands over far more than you want a customer to see — assignees, estimates, priorities and conversations meant for your team.

The Customer Portal gives you a middle path. Turn it on for a project and your customer sees their tasks as a clean list, with a title, a plain-language status, and nothing else: no internal fields, no priorities, no who-is-doing-what. Any task you'd rather keep internal stays internal with a single switch — it simply never appears on their side. Picture a client who's been asking for a progress update every Friday: once their project is shared, they can check it themselves at any time, see what stage each item is in, and leave a comment or request directly, instead of you writing a recap email each week.

How It Works

• Set it up once. Turn on the Customer Portal in Settings, upload your logo, and pick an accent color — the portal then carries your brand, not Effigate's.
• Share a project, task by task. Turning on sharing for a project exposes its tasks automatically; any task you mark internal is excluded, and nothing is shared until you choose to share it.
• Your board, their language. Your own board columns are translated into customer-friendly stages, and you can rename how each stage reads to them.
• One inbox per project. Your customer gets a single conversation list for each shared project — searchable, with formatted messages and screenshots — plus a Home page summarizing progress and recent activity.
• Requests stay separate from your team's comments. Anything a customer asks for lands in its own Requests queue inside Command Center, never mixed into your team's internal task discussion. Reply and they see it in the portal and by email; add an internal note and it stays yours. One click turns a request straight into a task, pre-filled with the customer's own words.
• You control access. Invite people from a customer's page; they get a branded email and set their own password or sign in with a one-time link. Resend an invite, reset a password, or revoke access at any time.

Where to Find It

The Customer Portal is available now on every Effigate Command Center account. Turn it on in Settings → Customer Portal, then enable sharing from any project's settings — it's off by default until you choose to share.

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

Summary

Effigate Command Center's project memory has been redesigned so that each task's agent writes its own dedicated memory file, rather than every task sharing and editing the same document. That one change removes a reliability problem where multiple pieces of work in progress at once could end up conflicting with each other purely because they were trying to update the same shared file.

What You Gain

Previously, every agent run added its own notes to one shared project memory document, which meant any two pieces of work in progress at the same time were liable to edit the exact same lines of that document. Merging one piece of work could instantly create a conflict in another unrelated piece of work still in progress, simply because both happened to update their notes in the same place — occasionally backing up your whole review queue over something that had nothing to do with the actual code being reviewed.

Now, your project's main memory document keeps only the stable, big-picture information — your project's overview, structure, and conventions — while each task writes its own dedicated memory file as part of its own work. Two tasks never touch the same file, so this entire category of conflict is gone. Because each task's memory travels with its own change, canceling or reverting a task now also cleanly removes its memory entry, and a fresh look at your project only ever reflects the history of work that actually went through.

Once a task's work is merged, its memory becomes part of your project's record automatically, shown newest first, so your project's accumulated knowledge is always a clear, readable log of what actually shipped.

How It Works

• Your project's main memory document now holds only stable, high-level information: overview, structure, features, and conventions.
• Each task writes its own dedicated memory entry as part of its own work, so two tasks in progress at once never conflict.
• Once a task's work merges, its memory entry is automatically folded into your project's record, newest first.
• Canceling or reverting a task cleanly removes its memory entry along with it.
• This requires your project's GitHub connection to have read access to your repository's contents; without it, a simpler activity note is used instead.

Where to Find It

Find your project's accumulated memory on its Brain tab. Existing projects are already using the new structure — there's nothing you need to set up, beyond making sure your GitHub connection has read access if you want the full merged view.

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

Summary

The Effigate command-line tool now supports sprints as a first-class resource alongside tasks and projects — you can list, view, create, update, and delete a sprint, and see every task scheduled inside it, without leaving the terminal.

What You Gain

Previously, managing sprints was only possible through the web app. If your workflow lived mostly in the terminal — scripting routine project setup, or working from the command line by habit — there was no way to touch sprints at all without switching over to the browser. Now every core sprint action is available as a command-line command, returning the same table or structured data format you're already used to from working with tasks and projects.

How It Works

• List, view, create, update, and delete sprints directly from the command line.
• See every task scheduled inside a specific sprint, in the same format task listings already use.
• Every sprint command works within a specific project, since a sprint always belongs to exactly one.

Where to Find It

Available now in the Effigate command-line tool for anyone signed into their workspace — no extra permission needed beyond that. Run effigate sprint --help to see the full list of commands.

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

Summary

Deleting a project, task, agent, team, or other core item in Effigate Command Center now requires you to type a short confirmation phrase before the delete button unlocks, and the deleted item can be restored afterward if you change your mind.

What You Gain

Previously, deleting almost anything in the product — projects, agents, tasks, teams, users, and more — was a single click plus a basic Yes/No confirmation, and a few specific actions, like removing a single checklist item, had no confirmation at all. That made it easy to delete something by reflex, without a clear sense of what else it might affect. Where deleting one thing also removes related things — a project's tasks and documents, a team's members, an employee's records — there was previously no warning that this would happen.

Now, every one of these deletions opens a confirmation dialog that explains exactly what else will be affected, and deleting the main item itself requires typing a short confirmation phrase before the delete button becomes clickable — a deliberate extra step, not a reflex click. And just as importantly, many of these deletions are no longer permanent on the spot: a deleted project, agent, task, user, or similar item disappears from your lists immediately but can still be restored afterward, the same way team and employee deletions already worked. Deleting a task also now properly cancels any agent run still in progress for it, instead of leaving it dangling.

How It Works

• Deleting a project, agent, task, team, user, or similar core item now opens a confirmation dialog that explains what else it affects.
• Deleting the item itself requires typing a short confirmation phrase before the button unlocks.
• Many of these deletions can now be restored afterward, rather than being immediately permanent.
• Deleting a task with an agent run in progress now properly cancels that run.
• Removing a user no longer permanently blocks re-inviting the same email address later.

Where to Find It

This applies automatically to delete actions across your account — there's nothing to configure. Look for the restore option wherever you'd expect to find recently deleted items for a given area.

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

Summary

Commits and pull requests created by an agent's run are now clearly credited to Effigate Command Center in your repository history, instead of carrying a generic default from the underlying coding tool.

What You Gain

Previously, a commit or pull request made by one of your agents carried whatever default attribution its underlying coding assistant happened to use — which didn't tell you, or anyone reviewing your repository's history later, that the work came through Effigate Command Center specifically. Now every agent-authored commit and pull request clearly states that it was generated with Effigate Command Center, making your repository's history easier to read and audit at a glance.

How It Works

• Every commit and pull request an agent creates now carries a clear Effigate Command Center attribution line.
• This is enforced for every supported coding assistant your agents use, so the attribution holds consistently across providers.

Where to Find It

This applies automatically to every new agent commit and pull request — 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

A team- or company-shared agent showed up correctly on your Agents page, but not always in the Assign-To picker when assigning a task — so you could see that a shared agent existed but not actually hand it work. Both now show the same list.

What You Gain

Previously, the task assignment picker used its own, narrower rule for which agents to show, one that didn't account for agent sharing properly — so it only ever listed agents you personally owned, even if a colleague's agent had been explicitly shared with your team or company. A related gap in the picker used specifically for assigning a code reviewer went the other way: it had no visibility check at all, and could offer up a colleague's private agent as a reviewer.

Both pickers now use the exact same rule the Agents page already relies on, so what you can see is always what you can actually assign. Assigning a shared agent already worked correctly once picked — this was purely about which agents showed up as options in the first place.

How It Works

• The Assign-To picker on a task now shows every agent shared with you, not only ones you personally own.
• The reviewer picker on a project now respects the same sharing rules, instead of showing agents it shouldn't.

Where to Find It

No setup needed — this applies automatically the next time you open the Assign-To or reviewer picker on any task or project.

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

Summary

A skill's supporting files are only useful if its instructions can actually find them. A gap in one upload path could previously cause a file's saved location to not match where the skill's own instructions expected it — with no sign of the mismatch until an agent tried to use it. Skill file management is now clearer end to end: you can see exactly where every file will land before you upload it, and a broken reference is flagged immediately.

What You Gain

Previously, one specific way of creating a skill — starting from a template — could save a supporting file to a slightly different location than intended, so the skill's own instructions pointed at a file that technically didn't exist where expected. The only sign anything was wrong was an agent quietly failing to find it during a run. That inconsistency is now fixed with one shared rule applied everywhere a file gets uploaded, so every skill's files land exactly where its instructions say they will — including skills created before this fix.

Managing a skill's files is also much clearer now. A skill's page shows the exact folder its files will be saved into, and uploading a file now shows you the resulting path live, as you type, instead of only after you click Upload. Dropping in a whole folder of files keeps its structure instead of flattening everything to one level, and uploading to a path that already has a file at it replaces that file cleanly instead of creating a silent duplicate. If an instruction in a skill points at a file that doesn't actually exist, that's now flagged directly on the page.

How It Works

• The exact destination folder for a skill's files is now shown clearly on the skill's own page.
• Typing an upload path shows you the resulting location live, before you click Upload.
• Uploading a folder preserves its original structure instead of flattening it.
• A broken reference — an instruction pointing at a file that isn't there — is flagged directly on the page, not just discovered when an agent runs.
• Viewing and editing a supporting file now uses the exact same panel and controls as the skill's main instructions file, so both feel like one consistent experience.

Where to Find It

Available automatically on every skill in your account — including ones you created before this update, since the underlying file-location fix applies retroactively.

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

Summary

Your workspace now has its own timezone and country setting in Settings, every relative timestamp in the product shows the exact date and time when you hover over it, and a merged pull request now posts directly into the task's own comment thread, not just an activity log.

What You Gain

Previously, every relative time shown across the product — "2 days ago," for example — told you how long ago something happened, but not exactly when, making it hard to tell if an event landed during business hours or lined up with something else you cared about. There was also no workspace-level timezone at all, so every relative time defaulted to a generic reference point regardless of where your team actually works. Separately, when a pull request merged on GitHub, that information reached your Slack channel and the people following the task, but never appeared in the task's own comment history, so the thread didn't tell the complete story of what happened.

Now you can set your workspace's timezone and country directly in Settings, with a searchable picker instead of a long list to scroll through. Every relative timestamp across the product — in comments, your notifications, your Decision Queue, and your dashboard's activity feed — shows the real date and time, in your workspace's timezone, when you hover over it. And a pull request merging now posts directly into the task's own comment thread, credited to GitHub itself, alongside the existing Slack and assignee notifications.

How It Works

• Set your workspace's timezone and country from Settings → Workspace, with search to find either quickly.
• Hover any relative timestamp anywhere in the product to see the exact date and time, adjusted to your workspace's timezone.
• A merged pull request now appears directly in the task's own comment thread, in addition to the notifications you already received.

Where to Find It

Set your timezone and country under Settings → Workspace. Until you do, times default to UTC. The hover timestamps and merge comments apply 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

Your Decision Queue is deliberately hard to silence — an item is meant to stay until the thing it describes is actually resolved, not until someone decides to look away. A new, narrowly scoped Hard Clear option now gives you one permissioned way to remove a specific item when a person — not the system — has genuinely decided nothing further should happen on it.

What You Gain

Previously, there was no way to remove an item from your Decision Queue except by actually resolving whatever it described. That's the right default, but it meant a judgment call — "we're not doing anything about this one" — had nowhere to go except staying visible indefinitely, or being lost entirely if someone just stopped looking at it. Hard Clear fills that gap without weakening the rest of the queue: clearing one item only removes that one signal, not the rest of that task's queue entries, and it doesn't prevent a genuinely new issue on the same task from showing up again later.

Using it asks for a reason first — not actionable, handled outside the system, won't fix, a duplicate, or your own note — and records who cleared it and why directly on the task's own activity history, so the decision leaves a trace instead of disappearing silently.

How It Works

• Find Hard Clear next to Retry run in a task's guidance panel.
• Choose a reason from a short list, or add your own note.
• The clear, who did it, and why, are recorded on the task's own activity log.
• Only that specific item is cleared — the rest of the task's Decision Queue entries, and anything new that comes up later, are unaffected.

Where to Find It

Hard Clear is controlled by a specific permission that account administrators can grant from Settings → Roles — it isn't available to everyone by default.

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

Summary

A task could reach the point where an agent considers its work done and ready for your review, while an earlier question from that same work still sat open in your Decision Queue — asking you to answer something the agent itself had already moved past. Open questions now automatically resolve once a task is genuinely wrapped up.

What You Gain

Previously, nothing connected an open question to the eventual state of the task it came from, so a question could keep showing up in your queue well after it stopped being relevant — adding noise to a list that's meant to be a reliable list of things that genuinely need your attention. Now, once a task reaches the review stage and the most recent update on it came from the agent itself, any earlier open question on that task is automatically treated as resolved. This is deliberately narrow: a human's own comment never triggers this on its own, and a task that's still actively being worked on keeps its questions open exactly as before.

A related improvement cleans up escalated runs the same way: once a task has wrapped up this way, you're shown whatever the agent actually left behind, like a pull request ready for review, rather than an outdated escalation notice from earlier in the run.

How It Works

• A task's open questions clear automatically once it reaches the review stage with the agent's own comment as the most recent update.
• This never triggers from a human's own reply — only from the task genuinely being wrapped up by the agent.
• Decision Queue rows now also show the task's own reference number next to its title, matching what you see on the task's own page.

Where to Find It

This runs automatically for every task — 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

Some teammates could previously see fewer shared agents — and in a separate issue, more machines — than they should have, caused by a gap in how people were being added to teams. Both are fixed, agent sharing options are now clearer, and you can share an agent with your whole company at once for the first time.

What You Gain

Previously, a colleague added to your account without being placed on a team would quietly see less than everyone else — no shared agents, and several other team-scoped features like labels, SOPs, and the calendar either missing or incomplete for them, with nothing on screen to explain why. The same underlying gap also caused the opposite problem in one specific case: it could cause someone to see every machine registered to the company instead of only the ones they should.

People added without a team are now automatically added to their company's own team, and adding someone new now clearly asks you to set their team up front. Agent sharing itself is also clearer: what used to be called "Workspace" visibility — which actually meant your team, not literally your whole workspace — is now called Team, and a new Company option lets you share a general-purpose agent with everyone in your organization at once, without creating a separate copy for every team.

How It Works

• Adding a new person now asks for their team, and warns you if you leave it blank.
• People already added without a team have been placed on their company's team automatically.
• Agent visibility is now Private (just you), Team (everyone on this agent's team), or the new Company (everyone in your organization).
• Any agent or Quick Action already shared under the old "Workspace" label keeps exactly the same visibility — nothing changes hands.
• An agent's own page now clearly names which team it belongs to.

Where to Find It

Manage this from your Agents page (visibility) and your Users settings (team assignment). Available to anyone who can already manage agents or users on your account.

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

Summary

There was previously no reliable way to tell which version of Effigate Command Center a given agent, or the machine it runs on, was actually using — especially for the desktop app, which never reported its version at all. That's now visible everywhere it matters: on your agents, your machines, and every task's own run history.

What You Gain

Before this, the version information shown for a machine running agents reflected whatever program happened to start it, not necessarily the actual app doing the work — and the desktop app specifically never reported a version at all, so every machine running it showed up as unknown. There was also no way to tell a machine running the desktop app apart from one running the standalone command-line tool. If an agent behaved unexpectedly, there was no reliable way to confirm exactly which build it ran on.

Now both the desktop app and the command-line tool report their own version clearly, and because the desktop app bundles the command-line tool inside it, a desktop machine shows both numbers — which don't always have to match, since the two are released independently.

How It Works

• Your Agents list shows the Effigate build behind each agent, right under its machine name.
• Your Runtimes page, and each machine's own page, show both version numbers where relevant.
• Every task's run history records the exact versions used for that run, so a problem can always be traced back to the build that caused it.
• A machine that hasn't restarted since this update simply shows "version not reported," so it's clear it needs an update rather than looking broken.

Where to Find It

Restart your desktop app or command-line daemon to start reporting your version — the display itself works automatically as soon as that's done.

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

Summary

Replying inside a comment thread used to be a stripped-down experience, missing the mention list, Quick Actions, and note option that the main comment box already had. Replies now offer the exact same tools.

What You Gain

Before this fix, typing a reply to an existing comment gave you no list of who you could mention and no way to post without triggering an agent — even though a reply actually notifies and triggers things exactly the same way a regular comment does. That mismatch made it easy to mention someone in a reply without realizing it, or to want a quiet reply with no way to make one.

Replies now show the same mention autocomplete, your saved Quick Actions, and the /note option that top-level comments already have, so you have the same control either way.

How It Works

• Typing @ in a reply now shows the same autocomplete list as a regular comment.
• Your Quick Actions and markdown shortcuts are available from the / menu in replies too.
• /note works in a reply the same way it does in a comment — it reaches whoever you mention without starting an agent.

Where to Find It

No setup needed — available automatically the next time you reply inside any comment thread.

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

Summary

Typing / in a task's comment box already offered quick markdown formatting. It now also surfaces your saved Quick Actions, and adds a brand-new /note option for leaving a comment that reaches the people you mention without ever starting an agent.

What You Gain

Quick Actions already let you fire a saved prompt at an agent with one click from a task's header or side panel — but that sends the prompt exactly as saved, with no room to add context first. Now, picking a Quick Action from the / menu drops its message into the comment box as editable text, so you can add a note before sending it, rather than firing it blind. The one-click buttons are still there for when you want the prompt sent immediately.

Separately, there was previously no way to post a comment that mentions someone purely for their attention, without also risking it being read as an instruction to an agent. /note fills that gap: it posts without triggering any agent or automated workflow, even if it mentions one, and is clearly marked as a note in the comment thread. Anyone you mention in a note is still notified — the note still reaches them, it just doesn't start anything.

How It Works

• Type / in any task's comment box to see markdown shortcuts and your saved Quick Actions together.
• Picking a Quick Action inserts its message as editable text instead of sending it immediately.
• Type /note to post a comment that never triggers an agent or automated step, even if it names one.
• People you mention in a note are still notified, same as in a regular comment.
• Both the / and @ menus can now be used entirely from the keyboard: arrow keys to move, Enter or Tab to choose, Escape to close.

Where to Find It

Available to everyone in every task's comment box, with no setup required. Quick Actions whose agent has since been removed won't appear in the list.

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 tell Effigate Command Center which branch your agents should build their work on for a given project — useful for teams that keep their default GitHub branch separate from the branch they actually want new work layered onto.

What You Gain

Until now, every agent task always branched from your repository's own default branch, whatever that happened to be set to in GitHub. Teams that work differently — building on a develop branch before anything reaches their default branch, for example — had no way to tell Effigate Command Center that. Agents had no choice but to target the default branch directly, which didn't match how those teams actually ship code.

Now a project's connected repository can specify its own base branch. Leave it unset and nothing changes — agents keep targeting your repository's real default branch exactly as before. Set it, and every agent task for that project builds on the branch you chose instead.

How It Works

• Open a project's Resources, edit the connected GitHub repository, and set a base branch if you want one other than the default.
• Leave it blank to keep using your repository's actual default branch, with no other change.
• Every new agent task for that project respects this setting automatically going forward.

Where to Find It

Find this under Project → Resources, on the settings for a connected GitHub repository. Available to anyone who can edit a project's resources.

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

Summary

When a task is broken down into sub-tasks, Effigate Command Center now enforces a strict, predictable order for how the parent task and each sub-task run — the parent plans, each stage of sub-tasks runs in turn, and the parent wraps everything up at the end. Several long-standing reliability problems with staged work all traced back to the same gap: nothing previously stopped a parent task's own agent from running at the same time as the sub-tasks it was meant to be coordinating.

What You Gain

Previously, a parent task's coordinating agent could end up redoing the very work its sub-tasks were created to handle, because the instructions it worked from didn't always reflect the breakdown that had just been created. Separately, assigning every sub-task at once could start the parent and its first stage of sub-tasks together instead of in sequence, and an urgent parent task's own queued work could jump ahead of the sub-tasks it was actually waiting on. On top of that, moving an agent-assigned task back into an active column from certain views sometimes did nothing at all — the task just sat there.

All of this is now fixed by enforcing one clear lifecycle: the parent plans the breakdown, the first stage of sub-tasks runs, the parent checks in on what came back and can still adjust later stages, the next stage runs, and so on — until every sub-task is finished, at which point the parent does its final integration and wraps up the whole piece of work. Each step only begins once the previous one has actually finished, so nothing has to remember to hand off to the next step, and a stage that fails or needs your attention still moves the whole chain forward rather than leaving it stuck.

How It Works

• A sub-task created while its parent is actively working is automatically held back, with a clear explanation of why and what happens next.
• Sub-tasks inherit their parent's priority, so an urgent parent's work is no longer queued behind sub-tasks whose own priority was lower by default.
• Moving an agent-assigned task into an active column reliably starts the agent now, whichever view you move it from.
• When a task's run is intentionally held back because its sub-tasks are still working, that shows up directly on the task's own activity timeline, so "why hasn't this started" always has an answer.
• The whole lifecycle — plan, run each stage, check in, integrate — is enforced consistently, so a parent task can no longer duplicate or race ahead of its own sub-tasks.

Where to Find It

This runs automatically for every project using staged sub-tasks — there's nothing to turn on, and it applies immediately to every account.

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

Summary

When two related pieces of agent work are in progress at the same time, it's possible for one to merge into a branch that the other has already abandoned — and until now, Effigate Command Center had no way to notice. It now checks every merge against your repository's actual main branch, and tells you plainly whenever work has landed somewhere that never reaches it, instead of marking the task done.

What You Gain

Previously, a task could be marked complete, show an "approved" notification, and have the right-looking merge notes — all while its actual code changes never reached your main branch at all. This happened when one piece of work built on another that was still in progress, and the one it depended on was merged and then abandoned before the second piece caught up. The system had no way to tell a healthy merge from one that landed on a dead end, so it reported success either way.

Now every merge is checked against your repository's real main branch. A normal merge, or one that lands on another task's branch that's still actively open, is treated as before. But a merge into a branch whose own related work has already finished is flagged immediately: the task is left exactly as it was, with a clear note explaining that its changes are stranded, rather than being silently marked done. The moment a branch is abandoned this way, anything still waiting on it is flagged too, so the problem surfaces right away instead of only after it causes a second, compounding issue.

How It Works

• Every merge is checked against your repository's actual default branch, not just assumed to be correct.
• A task whose pull request merges into an abandoned branch is flagged with an activity note and a notification, instead of being marked done.
• Pull requests tied to an abandoned branch lose their "ready to merge" badge in the task view, replaced with a clear warning to retarget them.
• These warnings also surface in your Decision Queue, so you don't have to stumble onto the affected task to notice.
• A parent task's own work is no longer allowed to merge while any of its related sub-tasks are still unfinished, closing a related ordering issue.

Where to Find It

This protection runs automatically on every project connected through GitHub — there's nothing to configure. You'll see the new warnings directly on a task and in your Decision Queue if this situation ever comes up.

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 several different ways to mark a task Done in Effigate Command Center — an Approve button, a status dropdown, and dragging a card on the board — and they quietly behaved differently from each other. All of them now go through the exact same step, so closing a task means the same thing, and is recorded the same way, no matter how you do it.

What You Gain

Previously, only some ways of closing a task recorded a completion date, and your dashboard's and profile's "tasks completed" figures are counted from that date — so work closed by dragging a card on the board was never actually counted toward those totals. Only one of the ways to close a task notified anyone that it had happened; close the same review by dragging instead, and nobody following that task heard about it. Closing a task from the board also had no permission check at all, meaning anyone could close a restricted review simply by dragging its card, bypassing a restriction the task's own detail view enforced.

Every way of closing a task now records the same completion date, sends the same notification, and applies the same permission check. A one-time repair also filled in the missing completion dates on tasks that were already closed, so your historical reporting stops under-counting older work.

Notifications for a task reaching "ready for review" are more accurate too — they now follow the task's actual status, rather than when an agent's run happened to finish, and only go to people actually following that task rather than every manager across your account.

How It Works

• Marking a task Done through any method — the Approve button, the status menu, or dragging its card — now records the same completion date and counts toward your reporting.
• Everyone following a task is notified the same way regardless of which method closed it.
• Closing a task requires the same permission everywhere, closing a gap where dragging a card could bypass a restriction.
• "Ready for review" notifications now follow the task's actual status change, reaching the people following that specific task.
• Two redundant buttons that duplicated other, already-working features have been removed.

Where to Find It

This applies automatically to every task across your account — there's nothing to configure, and your historical completion numbers have already been corrected.

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

Summary

Two separate gaps could leave agent-assigned work from actually starting: moving a parked task back into an active column didn't always wake its agent, and mentioning an agent on a closed task was silently ignored. Both are fixed, so assigned and mentioned work now reliably reaches the agent it's meant for.

What You Gain

Previously, a task that was intentionally held back — for example, waiting for someone to review before starting — could get stuck even after it was moved into an active column, with no agent run actually beginning. You'd move the card and nothing would happen, with no indication of why. Separately, assigning an agent to a task that's deliberately being held back is meant to record who will do the work without starting it immediately, which is useful for setting up a whole batch of work at once — but there was previously no visible sign this had happened, so it looked identical to the task simply being ignored.

Mentioning an agent on a task that's already closed was also silently dropped, meaning the comment posted but the agent was never actually asked anything — useful for flagging a regression on finished work, but broken until now.

How It Works

• Moving a held-back task into any active column now reliably starts its assigned agent.
• Assigning an agent to a task that's intentionally on hold still doesn't start it immediately, but now shows a clear note explaining why, along with a Start now button.
• Mentioning an agent now works at any task status, including closed tasks — useful for flagging that something needs another look.

Where to Find It

No setup needed — this applies automatically across every project with agent-assigned tasks.

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 previously let one task's branch build directly on top of whatever branch a different, unrelated task happened to leave open — a shortcut meant to avoid conflicts that could, in rare cases, cause a task's finished work to never actually reach your main branch. That shortcut is gone, replaced with a clearer, more predictable set of rules for how every task's work gets built and merged.

What You Gain

Before this change, if two tasks ran in quick succession, the second could end up branching from — and opening its pull request against — whatever branch the first task had just created, purely to avoid stepping on unfinished work. That worked most of the time, but it meant a task's fate was quietly tied to an unrelated task's branch. If that branch was abandoned once its own work merged, the second task's changes could be left stranded without ever reaching your main branch.

Now, related sub-tasks under the same parent task share one common branch that only merges into your main branch once at the end, after every sub-task's work is already on it. A standalone task always branches from a freshly updated, known-good starting point — either the base branch you've configured for the project, or your repository's real default branch — never from another task's branch. If an agent still opens a pull request against the wrong branch, Effigate Command Center now checks and automatically retargets it.

How It Works

• Sub-tasks under the same parent share one integration branch, which merges into your main branch only once, at the end, with every sub-task's work included.
• A standalone task always branches from an up-to-date, known starting point, never from another task that happens to be mid-flight.
• Every starting branch is refreshed from your repository before a task branches from it, so agents never build on something already out of date.
• If a task needs to retry, it reuses its own existing branch when earlier work on it is still unmerged, and rebuilds cleanly from the base branch when that work has already landed.
• If an agent opens a pull request against the wrong branch anyway, Effigate Command Center automatically retargets it to the right one.

Where to Find It

This applies automatically to every project with agent-assigned tasks, on both the desktop app and the standalone command-line tool — 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 sub-task could previously sit untouched for a long time with no one told why, caused by a handful of separate reliability gaps in how Effigate Command Center detects, reports, and recovers from a stuck or failed agent run. All of them are fixed, and failed runs are now easier to spot, understand, and restart.

What You Gain

Previously, a run could be incorrectly treated as blocked by unrelated files an agent's own test suite created inside dependency folders, even though nothing about your actual work had changed. A run could also be marked as failed purely because its activity log was slow to upload, discarding work an agent had already finished and committed. When a run was automatically retried, the record of its original failure was sometimes wiped out, leaving no way to tell what had actually gone wrong the first time. And when a run failed in a way nobody was actively watching — common for work handed entirely to an agent — the notification that should have gone out sometimes went to nobody at all.

All four of these are fixed. Scratch files an agent's own tests create inside dependency folders no longer block a run. A slow or failed log upload now costs you part of the log at worst, never the actual work. Every failed attempt is recorded in the task's own history before anything retries, so you can always see what was tried and what happened. And when there's no one specific to notify, the alert now falls back to your managers and your project's connected Slack channel instead of going nowhere.

How It Works

• Scratch files an agent's own tests create inside dependency or build folders no longer block the next task from starting.
• A slow or failed log upload no longer causes a finished, committed run to be marked as failed.
• Every failed attempt is saved to the task's history, so you can see exactly what was tried and why it failed.
• If there's no one specifically following a task, failure alerts now reach your managers and your project's Slack channel instead of disappearing.
• A failed run now shows a Retry run button directly on the task and in your Decision Queue — no command line needed.

Where to Find It

Reporting and retry improvements apply automatically across your account. Make sure your desktop app or standalone command-line tool is up to date to get the full set of fixes.

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

Summary

Before running a task against a local project directory you manage yourself, Effigate Command Center checks that it has no unsaved changes and brings it up to date. That check could previously be fooled by an unrelated problem with the repository itself, letting an agent run against a folder that hadn't actually been verified safe. It now tells a genuine problem apart from a folder that's simply clean and ready.

What You Gain

Previously, if the safety check itself failed for a reason unrelated to your actual work — a permissions issue, a temporarily locked repository, or a repository that was simply too large to check in time — Effigate Command Center treated that failure the same way it treats a folder that isn't a repository at all: it skipped the check and let the task run anyway. That meant an agent could occasionally be let loose on a directory that was never actually confirmed to be safe, including one that might have held work you hadn't saved yet.

Now, a folder that genuinely isn't a project repository is still skipped exactly as before, and so is a clean one with nothing to update. Anything else stops the task and shows you the actual problem, so you can resolve it before any agent touches that folder.

How It Works

• A local directory that isn't a git repository is still skipped, exactly as before.
• A clean, up-to-date directory still runs normally.
• Any other repository problem now stops the task and shows the real error, instead of letting the task proceed.

Where to Find It

This applies to any project set up to run against a local directory. Update to the latest desktop app or standalone command-line tool to get this fix — it isn't a server-only change.

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

Summary

Some desktop app updates were quietly shipping with older internal components than intended, which meant a few fixes — especially around Windows task handling — weren't reaching customers even after they'd been released. Desktop releases now rebuild every bundled component before packaging, so what you install always matches what's actually been fixed.

What You Gain

Previously, the pieces that power the desktop app's task automation could lag behind the rest of the app in a release, even though nothing about that looked wrong from the outside — the version number moved forward, but the underlying behavior sometimes didn't. If you noticed a Windows-related fix announced in one release but didn't see the improvement in your own installation, this was very likely why: your download had the new wrapper around old internals.

Desktop releases now guarantee every internal component is freshly built before anything is packaged, so an announced fix and the behavior you get are always in sync. If your machine also has a separate, manually installed command-line tool on its own update path, the app now records exactly which version it's using for each task run, so you can tell at a glance whether that one needs updating too.

How It Works

• Every desktop release rebuilds all of its internal components from the current source before packaging, not just the parts that changed on the surface.
• This applies to every platform the desktop app ships for, including Windows.
• If a separate command-line install exists on your machine, each task's run history now shows exactly which version handled that run.

Where to Find It

Nothing to configure — this applies to every desktop app release going forward. Update to the latest desktop app version to make sure you're on a build with this fix.

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

Summary

Mentioning someone by name in a task's comment box didn't always notify them — a gap that made it easy to assume a teammate had been looped in when they hadn't. Mentions typed from the task view now behave exactly like mentions typed anywhere else in Effigate Command Center: the person is notified, and the mention is visibly highlighted.

What You Gain

Before this fix, mentioning a person's name in a comment posted directly from a task's detail view was unreliable: unless that person was already following the task for some other reason, they received no notification at all. Mentioning an agent still worked as expected, but a human teammate could be mentioned and never know it. The highlighted, colored styling that marks a mention was also inconsistent — a mention typed in a different letter case than the person's actual name would still notify them correctly behind the scenes, but wouldn't visually highlight, making it look like the mention had failed even when it hadn't.

Now, mentioning a person from a task's comment box notifies them every time, and the mention is styled consistently no matter how you capitalize their name.

How It Works

• Typing @ and a teammate's name in a task's comment box notifies them, the same as mentioning them from chat or the command line.
• The mention is visually highlighted correctly regardless of capitalization.
• This brings the task view's comment box in line with every other place in the product where mentions already worked this way.

Where to Find It

No setup needed — this applies automatically the next time you mention someone from 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

Effigate Command Center's automatic task branching is now more reliable when tasks run back-to-back in the same project. A task that finishes can sometimes leave its own branch in place; the next task now recognizes that and switches away from it automatically, instead of silently falling back to a slower, less predictable way of starting work.

What You Gain

When one task finished and the next task started moments later in the same project, the system occasionally found itself sitting on the branch the previous task had just created. Rather than risk touching a branch a person might have intentionally left checked out, it played it safe and backed off — which meant the new task didn't get the clean, automatic start it was supposed to.

Now the system can tell the difference between a branch it created for a finished task and a branch a person is actually using. If it recognizes the branch as one of its own leftovers, it switches away from it automatically so the next task can begin on solid footing. Anything that looks like deliberate human work is still left alone.

How It Works

• Each new task checks whether the project is sitting on a branch left behind by a previous, already-finished task.
• If it is, the system switches to the right starting point automatically — no action needed from you.
• If the branch looks like something a person is actively working in, it's left exactly as is.
• This applies every time tasks run one after another in the same project, with no extra setup.

Where to Find It

This runs automatically for every project with agent-assigned tasks — there's nothing to turn on. You'll simply notice tasks starting cleanly even when they follow right after another task finished.

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

Summary

Fixed a brief issue that could leave the navigation sidebar empty for some accounts. It now always loads correctly, with your company and navigation showing as expected.

What You Gain

A short-lived timing issue from a recent account-isolation improvement could leave the sidebar blank instead of showing your navigation. That's resolved — the sidebar now always reflects your own company's information correctly.

How It Works

The sidebar's information now loads at the right point in each page request, after your company account is confirmed.

Where to Find It

This applies automatically; nothing to configure.

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

Summary

Effigate now creates each task's working branch itself, before an agent's run even starts, instead of trusting the agent to do it. Work can no longer accidentally land directly on your main branch.

What You Gain

Because branch creation used to depend on the agent following an instruction, a rare mix-up — like old, no-longer-relevant notes on a task — could lead an agent to conclude branching wasn't possible and do the work directly on the main branch instead. That's no longer possible: Effigate sets up the right branch deterministically before any agent CLI starts.

How It Works

If a task's checkout is on your default branch, Effigate creates (or reuses) that task's own branch automatically. A branch you're already using for a linked pull request, or one you've checked out yourself, is left untouched, and review-only runs never create a branch at all.

Where to Find It

This applies automatically to every agent task; nothing to configure.

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

Summary

Effigate Command Center now verifies which company account a request belongs to before it touches any data, at every point in the product — not only on the pages you see, but also in scheduled jobs and background updates. For teams running multiple projects with agents working around the clock, this means your boards, tasks, comments, and reports stay fully separate from every other company's workspace, with the same checks applied everywhere, all the time.

What You Gain

Previously, the checks that kept one company's data separate from another's were strongest on the pages you actively browse, where every click and page load confirms who you are and what you're allowed to see. Work that happens without a page open — a scheduled report, an agent finishing a task overnight, a notification being prepared — followed a looser path, since nothing was there to double-check it at the same depth.

Now every one of those paths, seen or unseen, runs the same ownership check before it can read or write anything. Picture two companies, each running their own projects and agents in Effigate Command Center at the same time: Company A's nightly task summary and Company B's agent run now both pass through the identical check, so a background process started for one workspace can never accidentally touch another's boards, tasks, comments, or files. You don't have to trust that only the parts you see are protected — everything behind the scenes is held to the same standard.

How It Works

• Every request carries its company context. Whether you open a project board, an agent kicks off a run, or a scheduled job wakes up, Effigate Command Center first confirms which company account it belongs to before doing anything else.
• Background work is checked the same way as a page load. Scheduled reports, overnight agent runs, and queued notifications now go through the identical ownership check as a page you open yourself, closing the gap where background work was checked less strictly.
• Real-time updates stay scoped too. Live activity feeds and notifications, the updates that stream in as agents work, are filtered by the same per-request check, so you only ever see activity from your own company.
• Nothing to configure. This protection applies automatically to every project, task, and agent in your account; there's no setting to turn on and no workspace to re-check.
• No change to how you work. Boards, tasks, comments, and reports look and behave exactly as before — the difference is entirely behind the scenes.

Where to Find It

This is already active on every Effigate Command Center account — there's nothing to enable and no settings to change. It applies automatically across every project, task, agent run, and background job in your workspace.

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

Summary

Every request made through Effigate's API now confirms which company account it belongs to before it runs, closing a narrow gap where some API activity could run without that check.

What You Gain

Picture two companies using the Effigate API side by side: before this fix, a handful of API requests weren't fully bound to the company that made them. Now every API request — and every link between records it creates, such as adding a team to a project — carries its company account from start to finish, so it can never cross into another company's workspace.

How It Works

Account binding now applies to the entire API surface, with the only exceptions being the few actions a brand-new user genuinely needs before they belong to a company yet, like accepting an invitation.

Where to Find It

This applies automatically to every Effigate account and API integration; nothing to configure.

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

Summary

A staged chain of sub-tasks no longer gets stuck if the parent task happens to finish before the chain does. Each finished stage now reliably opens the next one, whatever state the parent is in.

What You Gain

If a parent task's own work finished before its staged sub-tasks did, the next stage could end up waiting forever instead of starting — a frustrating dead end with no obvious cause. Now finishing a stage always opens the next one, regardless of what's happening on the parent task, so a staged plan reliably runs to completion. This closes a gap the fix that got stages actually running didn't cover: the parent task finishing first.

How It Works

• Stage releases are independent of the parent's state. A finished stage always opens the next one.
• A periodic safety check runs every few minutes, automatically releasing any stage that should have started but didn't — without affecting a stage someone deliberately paused on purpose.

Where to Find It

This applies automatically to every staged breakdown; nothing to configure.

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

Summary

Assigning an agent to a parent task and choosing Assign All to cascade it onto staged sub-tasks now starts the first stage right away, instead of leaving it waiting indefinitely.

What You Gain

Cascading an assignment onto a staged breakdown used to queue the parent correctly but leave every sub-task parked with no stage ever starting — including the very first one. Now the first stage releases itself the instant the cascade runs, so work begins immediately and the rest of the chain proceeds as expected. This fixes a gap in Assign All for staged breakdowns, the feature that introduced this cascade.

How It Works

Choosing Assign All on a staged parent task now triggers Stage 1 directly, instead of waiting for an earlier stage to finish first — which never happens on a fresh assignment.

Where to Find It

This applies automatically the next time you cascade an assignment onto a staged breakdown.

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

Summary

Staged task breakdowns are now more resilient end to end: a parent task's agent always sees the current state of its sub-tasks, and any pull request that somehow missed a review is automatically caught and reviewed on its own, a few minutes later.

What You Gain

A parent task's agent used to be briefed on its sub-tasks only once, at the moment it was queued — so anything that changed between queueing and the agent actually starting, like a sub-task being added or finishing, wasn't reflected, and the agent could duplicate work already done. Now that briefing is rebuilt right before the agent starts, from the current state of the breakdown. Separately, if a pull request's review was ever missed, it no longer stays unreviewed indefinitely — a periodic check now finds it and dispatches a review on its own, the same self-healing idea behind stages advancing themselves.

How It Works

• Fresh context at start time. A parent task's agent always sees the sub-tasks as they stand the moment it begins, not as they stood when it was queued.
• Self-healing reviews. Any open pull request without a review is automatically picked up and reviewed, independent of whatever usually triggers a review.

Where to Find It

This applies automatically to every staged breakdown and every pull request; nothing to configure.

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

Summary

Setting up the Effigate CLI when your account has access to more than one workspace is simpler now: you pick from a numbered list instead of copying and pasting an identifier.

What You Gain

Copying an identifier correctly is a small thing that's easy to get wrong. Picking a number from a list isn't.

How It Works

Running effigate setup now shows every workspace you can access as a numbered choice — just type the number for the one you want.

Where to Find It

Available now in the Effigate CLI setup flow for any account connected to more than one workspace.

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

Summary

Live activity updates and mobile push notifications are now more reliable, and a temporary hiccup in either one no longer delays or blocks the rest of your notifications.

What You Gain

Occasionally, a live-update hiccup or a mobile device without push notifications fully set up could interrupt notification delivery for everyone, even though the in-app and email notification had already gone out. Now each notification channel is handled independently, so a problem with one — like a brief connectivity issue or a device not yet registered for push — is skipped and logged instead of holding up or duplicating anything else.

How It Works

• Faster, more direct live updates, reducing the chance of a delivery hiccup.
• Mobile push is attempted only for devices that are actually registered for it, and any failure there is logged and skipped rather than stopping the notification.

Where to Find It

This applies automatically to every Effigate account; nothing to configure.

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

Summary

Events from connected tools — GitHub, Slack, and Autopilot triggers — are now correctly attributed to your company account from the moment they arrive, so anything they create always lands in the right workspace.

What You Gain

Incoming events from connected integrations previously weren't always bound to a company account the instant they arrived, which could cause a delivery to be lost rather than correctly filed. Now each event resolves its company from the connection that sent it — your GitHub installation, your Slack installation, your Autopilot trigger — before anything is created from it.

How It Works

Pull requests, chat sessions, and tasks created from an integration event are now stamped and scoped to your company from the start, so they're never misplaced or dropped.

Where to Find It

This applies automatically to every connected integration; nothing to configure.

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

Summary

Fixed an error that could prevent commenting on, @mentioning, or reviewing a task that has sub-tasks.

What You Gain

A recent change could cause an error on exactly that kind of task. It's fixed, and the whole codebase was checked for the same pattern so it can't resurface elsewhere.

How It Works

Comments, mentions, and reviews on tasks with sub-tasks now work the same as on any other task.

Where to Find It

This applies automatically; nothing to configure.

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

Summary

Fixed every agent task failing immediately when run on one of Effigate's supported coding agents. That agent can now create branches, commit, and push changes just like any other agent in Effigate.

What You Gain

Tasks assigned to that coding agent used to fail right at the start, before any real work could happen, on every operating system. That's resolved — it now has exactly the access it needs to do the job, no more and no less.

How It Works

Effigate now starts that coding agent with the access it needs for Effigate's own task workflow, while keeping the same working-directory and credential boundaries every agent already runs under.

Where to Find It

This ships with the current desktop app update, and applies automatically to any agent configured to use that coding agent.

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

Summary

Automated code review runs are now strictly read-only from start to finish, so they can never leave unrelated changes sitting around for the next task that runs in the same place.

What You Gain

A review run occasionally picked up instructions meant for task-building runs and made small unrelated edits, which could confuse whatever task ran next in the same space. Reviews now skip those instructions entirely, so they only ever read and comment.

How It Works

Effigate now recognizes a review-only run from the moment it starts and never hands it edit-style instructions.

Where to Find It

This applies automatically to every code review run; no setup is needed.

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

Summary

Reviewing a pull request that belongs to a staged breakdown of parent and sub-tasks now weighs the whole plan, not just that one task in isolation — so review feedback matches how the work was actually meant to be split up.

What You Gain

When a task is one stage in a larger breakdown, judging its pull request alone could produce the wrong call: flagging it as incomplete for work a later stage was always meant to handle, or approving it even though it quietly contradicted something an earlier stage already shipped. Now the reviewer sees every related task in the breakdown — its stage, its status, and how it fits in — before judging the change in front of it. This extends review to understand staged breakdowns the same way the rest of Effigate already does.

How It Works

• Full-family context. The reviewer reads the parent and every sibling sub-task's description and history before judging any one pull request.
• The right standard. Missing work that belongs to a later stage is no longer flagged as incomplete; contradicting an earlier stage's work still is.
• Bypass detection. If a parent's own pull request tries to absorb work that should have gone through its sub-tasks, the review now catches it and sends it back, instead of letting it merge.

Where to Find It

This applies automatically to every code review on a task that's part of a staged breakdown; nothing to configure.

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

Summary

Tasks created through AI Chat now arrive fully specified — with type, priority, estimated effort, a checklist when the work has multiple steps, dates when you mentioned timing, and the right parent-and-sub-task structure when items belong together — instead of just a bare title and description.

What You Gain

Creating a task from a quick chat message used to mean filling in the rest by hand afterward: deciding how big the work is, whether it needs a checklist, whether it should really be several linked tasks, and when it's due. Now AI Chat does that thinking for you. Say "set up the new client by Friday" and the resulting task already carries a sensible effort estimate, a checklist if the work has multiple steps, and a due date resolved against today — ready to review and confirm rather than build from scratch.

How It Works

• Complete proposals. Every task AI Chat proposes includes type, priority, effort, and a checklist where the work calls for one.
• Dates from plain language. Mention "next week" or "by Friday" and AI Chat resolves it to real start and end dates — shown on the proposal so you can adjust them before confirming.
• Structure when it's needed. Related work is proposed as linked parent and sub-tasks with stages, not one flat task.
• Works everywhere you create tasks from chat. Confirming one task, confirming several at once, or building a whole sprint from a conversation all carry the same complete detail through.

Where to Find It

Available now in AI Chat, both the assistant panel and the sidebar chat, for every Effigate account. Review and edit any proposed field before confirming.

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

Summary

An agent assigned to a parent task that already has sub-tasks now sees that breakdown and coordinates it, instead of treating the parent's description as its own job to finish from scratch.

What You Gain

Before this fix, a parent task's agent had no way of knowing sub-tasks already existed, so it could end up doing the whole job itself while the staged sub-tasks did the same work separately — wasted effort, and sometimes conflicting results. Now the agent is handed the full list of existing sub-tasks, with each one's stage and status, and is told plainly that its job is to review the plan and coordinate, not to redo it. This rounds out sub-task stages from earlier this month, so the parent's own agent respects a breakdown it didn't create itself.

How It Works

A parent task's agent now receives an "Existing Sub-Tasks" overview before it starts, so it can check the breakdown, adjust a sub-task's description if needed, and let the staged work run as planned.

Where to Find It

This applies automatically to every parent task with sub-tasks; nothing to configure.

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

Summary

Every email Effigate sends — notifications and account emails alike — now shares one consistent, readable design that displays correctly on phones and in Outlook. Notification emails include a direct link to manage your preferences.

What You Gain

Emails that render inconsistently across phones and desktop mail clients are easy to skim past or distrust. The new shared design fixes that, so updates about your tasks and projects are easy to read wherever you check them, and turning off emails you don't want is one click away. Security-related emails, like sign-in codes and invitations, intentionally skip that link, since those can't be turned off.

How It Works

• One consistent layout across every email Effigate sends, with a clear header and a readable body.
• Renders correctly on phones and in Outlook, not just in modern webmail.
• Manage email preferences link on notification emails, taking you straight to your settings.

Where to Find It

This applies automatically to every email Effigate sends — nothing to turn on.

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

Summary

Joining Effigate from an invitation is now a single step. Click the link, choose a company name and a password, and your account and company are created together — already set up with a team, board, and starting structure — and you land straight on your dashboard.

What You Gain

Getting a new team onto a tool often means a gap between "we're interested" and "we're actually working in it," filled with setup steps someone has to push through. Now that gap is gone: picking a company name and a password is the entire setup. There's no separate configuration step afterward — roles, a default team, board columns, and document categories are already in place, so the first thing you see after signing in is a working Effigate, not an empty shell waiting to be configured.

How It Works

• One form, one step. Choose your company name and password; everything else is created for you.
• Ready immediately. Default roles, team, board, and categories are already set up when you land on your dashboard.
• Safe to send. Invitation links expire after two weeks and work only once, so an old link can't be reused later.

Where to Find It

Invitations are sent by the Effigate team when a workspace is requested. If you're waiting on access, no setup is required on your end beyond the link you'll receive.

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

Summary

Effigate now organizes everything — teams, projects, tasks, agents, invoices, expenses, and HR records — under your company's own account. Each company's workspace is its own self-contained space, with its own settings, numbering, and access, separate from any other company using Effigate.

What You Gain

Before this change, workspace-level settings and numbering sat closer to the individual rather than the company, which made it awkward for a growing team to present one consistent setup to everyone working under it. Now your company owns its own workspace end to end: its own name and AI context, its own task numbering, its own invoice numbers and expense categories, its own leave types and board defaults. If your company runs two teams side by side, both work inside the same clean, independent account instead of improvising around settings meant for a single team.

How It Works

• Your own workspace identity. Company name, AI context, and task numbering are set once and apply everywhere your team works.
• Independent numbering and defaults. Invoices, expense categories, leave types, and board columns start from your company's own sequence, not shared with anyone else.
• Desktop app and CLI access are company-bound. A connected device or CLI session only ever works inside the company it was set up for.
• New companies start ready to go. A fresh company account comes with a default team, board, roles, and expense categories already in place — nothing to configure before your first task.

Where to Find It

This applies automatically to every Effigate account; existing workspaces kept all their data and continued working without any setup. 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

Effigate now has a public website, separate from the signed-in app, for anyone who wants to understand the product before creating an account. It covers what Effigate does for different teams, shows real use cases, and gives new visitors a straightforward way to ask for access.

What You Gain

Previously, there was nowhere to send a colleague, a prospect, or your own manager who wanted to understand Effigate without already having a login — the product only existed behind sign-in. Now there's a proper front door: a homepage that explains what Effigate does, dedicated pages for how Engineering, Finance, Operations, Sales & Marketing, and Support teams each use it, and a use-cases page you can filter by scenario. If you're already signed in, visiting the site still takes you straight into your workspace, so nothing changes for existing customers.

How It Works

• Solutions by team — five pages tailored to how each function actually uses Effigate day to day.
• Filterable use cases — browse real scenarios instead of a generic feature list.
• A waitlist with a live signup count — request access and see how many others already have.
• About, Brand, and Privacy pages — the background information teams ask for before adopting a new tool.

Where to Find It

The site is live now at the Effigate domain for anyone not yet signed in. No account or configuration is needed to browse it.

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

Summary

When an agent run stalled and was automatically retried, the retry could sit waiting rather than starting right away, and the task could end up in a different place on the board depending on exactly how the failure happened. Both are fixed.

What You Gain

A retry that starts promptly instead of waiting around gets your work moving again faster. And a consistent landing spot on the board means a recovered task behaves the same way regardless of what caused it to need retrying, so you don't have to remember two different outcomes for what should be the same situation.

How It Works

Retries now start immediately rather than waiting for the next routine check. A task recovering from this kind of failure now always lands in the same working column, while a task that was already blocked or deliberately parked is left exactly where it was.

Where to Find It

This applies automatically to every agent run — no setup needed.

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

Summary

A project running for a while accumulates documents fast, and until now the Documents tab was one long, unfiltered list. It now has category and visibility filters, multi-select with bulk delete, and a merge tool that combines several documents into one.

What You Gain

Scrolling a long, flat list to find one document, or to clean up several that had grown redundant, wasted time that should have gone into the actual work. Now you can narrow the list in a couple of clicks, act on several documents at once, and consolidate overlapping ones instead of deleting and rewriting them from scratch.

Picture a project with a dozen scattered reference documents built up over months. With filters, you can narrow instantly to just the ones marked for agent use. With multi-select, you can tidy up outdated ones in one pass. And with merge, three overlapping documents become one clear document, with its content and visibility preserved — so tidying up never risks quietly losing information an agent was relying on.

How It Works

• Filter by category and visibility. Narrow the list by document category and by whether a document is always available to agents or only fetched on demand. A search box matches titles and summaries, and a Clear button resets everything.
• Select several documents at once. Tick documents individually or select all within your current filter.
• Delete in bulk, with a confirmation step before anything is removed.
• Merge into one. Combine selected documents into a single document — you choose its title and category, and you see exactly what it will contain before confirming. A merged document stays visible to agents if any of its parts were, so merging can never accidentally hide information an agent depended on.
• A more accurate token estimate. The figure showing how much of an agent's context your always-available documents use now reflects exactly what agents actually receive, rather than counting documents that don't reach them at all.

Where to Find It

Open any project's Documents tab to use filters, multi-select and merge — available now on every project.

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

Summary

Everything that needed a decision from you used to be scattered across the app — a question buried in one task's comments, a ready pull request on another, a failed run somewhere in the Inbox. A new Decisions page gathers all of it into one ranked list, and keeps it current automatically.

What You Gain

Answering "what actually needs me right now" used to mean checking several different places and hoping you hadn't missed one. That kind of scattered attention is exactly how small blockers sit unresolved for longer than they should, quietly slowing down whatever depends on them.

Now there's a single place: agent questions that stopped a run, failed runs that couldn't recover on their own, agents waiting on a local directory, pull requests ready to merge, and blocked tasks — all in one list, ranked by how stuck each one is. Clicking an item opens the task directly so you can act without navigating away.

How It Works

• Items are ordered by urgency: stalled work waiting on you comes first, followed by finished work ready to be released, then the rest.
• There's no dismiss button — an item leaves the list only when the real situation is resolved, wherever that happens: here, on the board, or on GitHub.
• The list updates itself both ways: new items appear as they arise, and resolved ones disappear immediately, moving you straight to the next item if you were working through the list.
• It sits alongside the Inbox but serves a different purpose — the Inbox shows what already happened, while Decisions shows only what is still waiting.

Where to Find It

Open the Decisions page from the main navigation — available now for every account.

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

Summary

A correctly configured local project directory could still go unused if you had more than one machine connected under the same account — agents would fall back to a fresh checkout instead, sometimes failing outright if the project's other resource needed access the fallback machine didn't have. It now always reaches the specific machine it was set up for.

What You Gain

If you run more than one connected machine — say, a Mac and a Windows machine both set up for the same account — this previously meant Effigate Command Center couldn't reliably tell which one actually held your local directory, and could pick the wrong one. Now the exact machine that claimed the task is the one that's used, every time, regardless of operating system.

Where to Find It

This fix applies automatically — no changes needed to your existing local directory setup.

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

Summary

Setting up the Effigate CLI on a new machine used to require developer tooling most teams don't want to maintain just to run a small command-line helper. It now installs as a ready-to-run download, and Windows machines — previously unsupported — now work properly too.

What You Gain

Before this change, every machine you wanted to set up needed a working developer toolchain installed, just to get one small CLI running — overhead that had nothing to do with the actual work you wanted to do. On Windows, there was no supported install path at all, so teams running Windows machines simply couldn't use the CLI.

Now setup is a single download with a built-in verification step, and the only requirement on the target machine is a standard, widely available runtime (Node.js 20 or newer). Re-running the installer upgrades it in place. Windows now has its own proper installer, and a mismatch that used to make the CLI invisible to coding agents on Windows — even when correctly installed — is fixed, so agents running on Windows can use it exactly as they can on Mac or Linux. This closes the loop on the Windows agent fix from earlier this month: that fix got stuck runs moving again, and this one makes sure Windows never has that problem on a fresh install.

How It Works

• The CLI installs from a verified, ready-to-run download — no separate build step or developer tooling needed.
• Windows now has a dedicated installer, alongside the existing one for Mac and Linux, both documented in the Desktop App / CLI guide.
• A Windows-specific compatibility issue that could make a correctly installed CLI appear missing to an agent is resolved.

Where to Find It

Reinstall using the latest installer from the Desktop App / CLI guide inside your account — existing installs can upgrade in place by re-running it.

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

Summary

Global search previously only looked across projects, tasks, customers, invoices and sprints — everything else in the app was invisible to it. It now resolves task identifiers directly and searches across six more categories.

What You Gain

Typing a task's own identifier into search used to rely on a text match against the title, which didn't always find it. Now typing the identifier jumps you straight to that task, every time.

Search also used to leave out entire areas of the app, so finding a specific document, agent, or team meant remembering which page it lived on and navigating there manually. Search now reaches into those areas too, each result respecting the same visibility you already have on that page, so nothing turns up that you couldn't otherwise see.

How It Works

• Typing a task identifier jumps straight to that task.
• Search now also covers Project Documents, Agents, Autopilots, Runtimes, Teams and Squads.
• Each category respects existing visibility rules, so results are always scoped to what you're allowed to see.

Where to Find It

Open global search (⌘/ or Ctrl+/) from anywhere in the app — this is live now for every account.

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

Summary

The Board now has a sprint filter alongside the existing project filter, letting you narrow it to any combination of sprints — including an option for tasks with no sprint at all.

What You Gain

Without a sprint filter, the Board showed every task from every sprint you'd ever run, which gets noisy fast on a project with a long history. Now you see only what's actually relevant to the sprint or sprints you're focused on.

How It Works

The filter is multi-select, so you can combine any sprints you like, plus an Unscheduled option. The first time you open the Board, it defaults to Unscheduled plus whichever sprint is currently active. Your choice is then remembered per browser, so the Board opens exactly as you left it next time.

Where to Find It

Open the Board on any project — the sprint filter sits next to the project filter, available now for every account.

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 run failed, it used to stop and wait for a person to read the error, decide whether it was worth retrying, and press the button. Failed runs now diagnose themselves, retry automatically when that's likely to work, and escalate to you — with a plain-language explanation — only when a person genuinely needs to decide something.

What You Gain

Most failures turn out to be a bad minute rather than a real problem, but someone still had to notice, read the error, and act on it every single time. That constant low-level attention adds up, especially across a team running many agents at once.

Picture a run that fails because of a brief network hiccup. Previously, that sat waiting for someone to notice and manually retry it. Now it's diagnosed, retried immediately with guidance about what went wrong, and a comment on the task explains what happened — all before you'd have even seen the failure. A genuinely stuck run — one needing a missing credential or a decision only a person can make — still reaches you, but with a clear explanation instead of a raw error.

How It Works

• Failed runs are automatically examined using the error, the run's recent activity, and what's already known about the project.
• If a retry could plausibly succeed, it starts immediately with added guidance, and a comment explains the diagnosis.
• A failure that can't be fixed automatically is escalated with a plain-language explanation and notifies the people following the task — this is the only notification you'll see for this kind of failure, since one that was already fixed automatically stays quiet.
• Each failure gets exactly one automatic retry attempt, so nothing loops forever or runs away with cost.
• Analytics separates failures that needed a person from ones that were recovered automatically, so you can see whether things are actually improving.

Where to Find It

This runs automatically on every agent run — no setup required. Check Analytics to see the automatic-recovery rate for your own projects.

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 activity announced itself in real time. A teammate editing a task, dragging a card on the Board, ticking a checklist, or posting a review decision stayed invisible to everyone else until they refreshed. Every one of those changes now broadcasts live, from anyone, to every screen watching it.

What You Gain

Real-time collaboration only works if it's actually real-time for everyone doing the work, not just for agents. Before this, a team working the same board together had to refresh constantly to see what a colleague had just done — the kind of friction that makes a shared workspace feel stale even while people are actively using it together.

Picture three teammates working the same sprint: one drags a card to Done, another adds a comment, a third updates a due date. Previously, none of that reached the other two screens without a manual refresh. Now all three see each other's changes appear within moments, exactly as if they were in the same room. This builds on the Board and comment reliability fixes from earlier this month, extending live updates to everyone on the team, not just the cases that were breaking before.

How It Works

• Board — cards move, restyle and reassign live for changes made by anyone on any project.
• Task view and modal — properties, checklists, assignees, stage and status update live as they change elsewhere.
• Comments — every kind of comment, including review decisions, now broadcasts as it's posted, edited, resolved or deleted.
• Sprints, Inbox, Calendar and Agent views — sprint boards, new notifications, calendar dates, and agent status and run history all refresh live as the underlying work changes.
• Analytics — charts and leaderboards update as runs finish, batched sensibly so a busy period doesn't flood the page with re-loads.

A burst of related changes — an agent assigning ten sub-tasks at once, for example — is coalesced into one refresh rather than ten, so the experience stays smooth even during heavy activity.

Where to Find It

This is live now across the entire app, for every account — there is nothing to turn on.

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

Summary

Agent-authored pull requests used to arrive with passing checks and nothing else — whether the change actually did what was asked was still something you had to work out by reading the diff yourself. A second agent can now review every pull request automatically before it reaches you.

What You Gain

Passing checks tell you the code runs; they don't tell you it did the right thing. Reviewing every agent-authored change yourself, line by line, is exactly the kind of work automation should take off your plate — while still giving you a real opinion to rely on, not just a green checkmark.

Set a review agent on a project, and every pull request from that project's tasks is reviewed automatically: does it do what was asked, is it correct, does it follow your project's own conventions. The verdict and reasoning appear directly on the pull request, with findings posted as comments — and if changes are requested, the original agent picks them up, fixes them, and triggers a fresh review on its own.

How It Works

• Choose a review agent per project; every pull request from that project's tasks is reviewed automatically.
• A pull request only shows as ready to merge once the review approves the exact current version of the code — pushing new changes requires a fresh approval.
• Requested changes go straight back to the authoring agent, which fixes them and resubmits; this loop is capped, so a persistent disagreement between agents lands in your Decisions list instead of looping indefinitely.
• A reviewer never reviews its own work, and always reviews the exact pull request it was asked to, so the verdict always matches what's actually being merged.
• You can always take over and review a pull request yourself instead, falling back to automated checks alone.

Where to Find It

Set a review agent from a project's settings — available now on every project. One honest limit: this controls the readiness signal inside Effigate Command Center; the actual merge button on GitHub is still yours to press.

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

Summary

A local project directory could be configured correctly and still fail every task that touched it — a moved path, the wrong machine, or unsaved changes already sitting in it. Previously you only found out when a task failed. A new Verify button checks it directly, ahead of time.

What You Gain

Finding out about a setup problem from a failed task costs you the time the agent already spent attempting the work. Verifying first means you catch the problem before assigning anything, not after.

How It Works

The Verify button on any local directory asks that machine directly and reports back whether the path exists, whether it's a proper project repository, which branch it's on, and whether it has unsaved changes sitting in it — flagged clearly as something to resolve before you assign a task.

Where to Find It

Open a project's Resources tab and click Verify on any local directory — available now on every account.

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

Summary

The Sprints & Tasks table could previously only assign work to people. Clicking the assignee on any row now opens the same Members, Agents and Squads picker used elsewhere in the app, so you can plan and assign a whole sprint without leaving the table.

What You Gain

Planning a sprint is exactly the moment you're deciding who — or what agent — should take on each piece of work. Needing to leave the table to hand something to an agent broke that flow. Worse, an agent-owned task on this table previously just looked unassigned, since the column couldn't display it.

Now the table shows agent and squad owners correctly, and assigning directly here works exactly like assigning from the task view — including the same prompt to take a parent task's sub-tasks along, staged, if that task has any.

How It Works

• Click the assignee on any row to open the full Members / Agents / Squads picker, with search and presence indicators.
• The currently assigned person, agent or squad is clearly marked in the list.
• Assigning a parent task here triggers the same staged sub-task prompt used everywhere else in the app.

Where to Find It

Open the Sprints & Tasks tab on any project — this is available now for every account.

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

Summary

The Analytics page used to disagree with itself — totals that didn't add up, failures missing from the chart that showed up in the counts. It's now internally consistent, shows work currently in progress, and lists exactly which failures need a person.

What You Gain

Numbers you can't trust are numbers you stop checking. Previously, failures could be undercounted on the chart, different cards could measure different time windows without saying so, and a busy day with lots of work queued or running could look empty because none of it was reflected anywhere yet.

Now every card, chart and table on the page measures the same time range and reconciles with the others. There's a dedicated count for work currently queued or running, so a busy day actually looks busy. And rather than a bare failure count, you get a list of the most recent failures with the real reason each one happened — so you can act on the handful of repeated issues that, in practice, account for most of them.

How It Works

• Failed runs are now correctly included on the chart, and historical data has been corrected so past failures show up rather than staying hidden.
• All figures on the page — cards, chart, breakdowns and per-agent tables — now measure the same time range.
• A new In Flight figure and band on the chart show work that's queued or still running.
• Average completion times now include failed runs, not just successful ones, so slow failures aren't hidden from the average.
• A Runs that need attention section lists recent failures with the task, the agent, and the actual reason it failed.

Where to Find It

Open Analytics from any project — the corrected numbers are live now for every account.

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

Summary

Agents used to rediscover the same project quirks every single run. Now, when an agent learns something durable about a project, it writes that lesson down, and every future run in that project benefits from it automatically.

What You Gain

Picture an agent that works out, the hard way, that a project's checks only pass after a particular setup step. Previously, the next run — whether it was the same agent or a different one — hit the exact same wall and had to work it out all over again, burning time on something that was already solved once.

Now that discovery is recorded as a project-level lesson, not a one-off note tied to that single run. The next agent to touch the project sees it in its instructions automatically, so the quirk is paid for once rather than every time.

How It Works

• Durable discoveries — a setup step that has to come first, an unwritten convention, a fact about how the project is set up — are recorded automatically as lessons.
• A Memory tab on each project lists every current lesson, grouped by kind, showing which agent recorded it and when, with a delete option on each.
• The same lessons also appear as a read-only summary document on the Documents tab, since it's generated automatically rather than written by hand.
• To keep things manageable, lessons are periodically reviewed: near-duplicates are merged into the clearest version, and anything that turns out to be specific to one finished task rather than the whole project is dropped.

Where to Find It

Project memory builds itself automatically as agents work — check the Memory tab on any project to see what's been learned, and remove anything you'd rather agents forgot.

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

Summary

Updating the Effigate Command Center desktop app on Windows could fail silently, leaving you on an older version with no clear way to get current. That's fixed — Windows updates now install reliably, and the release process checks itself before publishing so a broken update can't go out again.

What You Gain

If you're on Windows and the desktop app hadn't updated in a while, this is why: a recent release line had an update file missing on the server, so the updater asked for a file that wasn't there and quietly gave up. The Mac version was unaffected, since it installs from a different file. This fixes the Windows side of the self-updating desktop app we introduced last month.

You'll now get the latest desktop app automatically, the way it's meant to work — no need to reinstall manually or chase down an installer yourself.

How It Works

Every release of the desktop app now confirms its installers are actually available before the update is announced to anyone. If a file is missing, the release is held back instead of being published broken, so you're never offered an update that can't install.

Where to Find It

No action is needed — the desktop app will pick up the fix the next time it checks for an update, and every release going forward is verified before it's published.

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

Summary

The updates page inside Effigate Command Center now does what it always promised: filter pills let you narrow the list to just fixes, just features, or any other type, and a filtered view is a real link you can share. Links to a specific older entry now work reliably too.

What You Gain

Previously, the filter pills on the page were there but didn't actually filter anything, and sharing a link to a specific entry only worked if it was recent — an older entry's link could land you on the wrong page entirely. Both are fixed: filtering narrows the list for real, the result is a shareable address, and a link to any entry, however old, now opens on the right one.

Where to Find It

The updated changelog page is live now inside your Effigate Command Center account — no setup needed.

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

Summary

Shortly after sub-task stages launched, they weren't working end to end: sub-tasks sat untouched, a finished stage never released the next one, and the parent task never woke back up. That chain is fixed — moving a staged sub-task into active work now reliably starts its agent.

What You Gain

A staged breakdown is only useful if each stage genuinely kicks off the next. Before this fix, sub-tasks created as part of a stage sat with nobody actually working on them, so the whole breakdown stalled at the first step and never progressed, however it was assigned.

Now, moving an agent-assigned sub-task into active work — whether that's an automatic stage promotion or you dragging the card yourself — reliably starts that agent. A sub-task created but deliberately held back correctly waits until it's promoted, so later stages still hold off as intended.

How It Works

The guidance given to agents working with staged sub-tasks was corrected at the same time, so the instructions they follow now match how staged work actually runs.

Where to Find It

This fix applies automatically to every project using sub-task stages.

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

Summary

Sub-tasks can now be grouped into numbered stages under their parent task. A stage acts as a checkpoint: work in a later stage only begins once every sub-task in the stage before it is actually finished, so a multi-step breakdown runs in the order you intended instead of all at once.

What You Gain

A task that breaks down into several steps — say, build the groundwork, then build on top of it, then polish — needs those steps to happen in order. Without a way to express that order, every sub-task was just one flat group, so there was no way to say "don't start step two until step one is genuinely done."

Picture a project with three stages: two sub-tasks to lay the groundwork, two to build the feature on top, and one to polish it. With stages, the two groundwork sub-tasks run first, and nothing in stage two is touched until both of those are complete — so you're never left reviewing work that was built on an unfinished foundation.

How It Works

• Sub-tasks can be grouped into any number of numbered stages under their shared parent.
• Sub-tasks left ungrouped behave exactly as before, counted as a single group.
• Later stages wait until every sub-task in an earlier stage is finished before anything in them starts.
• The current stage is visible on board cards, in sprint task rows, and inside the Task modal, so you can always see how far a breakdown has progressed.

Where to Find It

Sub-task stages are available on every project now — set them up when you break a task down into sub-tasks.

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

Summary

On the Chat page, choosing an agent and pressing Start used to silently do nothing — no chat opened, and no error appeared. That's fixed, and any future failure to start a chat now shows a reason instead of failing silently.

What You Gain

A click that does nothing, with no error, is the hardest kind of problem to work around — there was nothing to retry or fix. Starting a chat now works the way it should, and if it ever fails again for any reason, you'll see why directly under the Start button instead of being left guessing.

Where to Find It

This fix is live now on the Chat page — 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

A resolved comment thread used to stay marked resolved even after someone replied into it, so a thread could show a green check while an unanswered question sat right underneath it. Replying to a resolved thread now reopens it automatically.

What You Gain

A "resolved" marker is only useful if it means the conversation is actually settled. When a new reply could sit unnoticed under a stale resolved marker, the signal stopped being trustworthy — you had to open every thread to be sure nothing was waiting on you.

Now a thread also holds at most one resolved marker at a time, so two different people resolving the same discussion at different times can't leave it carrying two conflicting markers. Each resolution also records who resolved it.

How It Works

• Replying to a resolved thread reopens it automatically.
• A thread can carry only one active resolution; resolving a comment clears any other resolution already on that thread.
• It's worth knowing that resolving a thread is a marker for people only — it does not start, restart, or stop an agent. Mention the agent directly in a new comment when you want it to act.

Where to Find It

This applies automatically to every comment thread, on every task.

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

Summary

Messages, board changes and comments are meant to arrive live, without a page refresh. A misconfigured connection address could silently break that for some accounts, so nothing arrived until you refreshed manually. That's fixed.

What You Gain

If live updates ever seemed to stop working and only a manual refresh brought things current, this was almost certainly why — the address the app used to stay connected could be malformed in ways that made it unreachable.

That address is now cleaned up automatically before it's used, and if it's missing entirely, the app connects using the site you're already on instead of failing outright.

Where to Find It

This fix is already active on every account — no action needed on your side.

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

Summary

Links shared inside a task's comments now open in a new browser tab instead of replacing the page you were on. You can follow a link a teammate or an agent posted without losing your scroll position or a reply you had half-typed.

What You Gain

Comment threads often carry links to a design file, a staging link, or a related task. Clicking one used to navigate the whole page away from the task, so getting back meant reloading the task and scrolling back down to where you were — and anything you had started typing in the reply box was gone.

Now the link opens alongside your work. You keep the task open, your place in the thread, and your draft reply, and can simply switch back to the tab you were already in.

How It Works

• Any link inside a comment opens in a new tab automatically, whether it was typed by a person or posted by an agent.
• Your current task view, scroll position, and any unsent reply are left exactly as they were.
• This applies everywhere comments appear: the full Task view and the quick Task modal.

Where to Find It

No setting to turn on — every comment link behaves this way automatically, for every project and every account.

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

Summary

Sending a message to an agent that was already working on something used to silently cancel what you asked for first — it simply never ran. Messages now queue up and run one at a time, in the order you sent them.

What You Gain

If you've ever sent a follow-up thought to an agent mid-task, only to find your first request never happened, this is the fix. Nothing told you it had been dropped — it just didn't run.

Now every message you send is respected. A run already in progress is never interrupted, and the next message in line starts the moment the one ahead of it finishes — so you can keep adding thoughts without worrying about losing earlier ones.

How It Works

Follow-up messages queue automatically and are never allowed to run at the same time as an existing run on the same task, which also prevents two runs from working against the same files at once.

Where to Find It

This applies automatically everywhere you message an agent — 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

Tasks with a long back-and-forth can bury the one comment you're looking for. A new thread finder in the Task view and Task modal lets you search by text or author, filter by status, and jump straight to the comment you need.

What You Gain

Before this, finding a specific comment in a busy task meant scrolling and reading until you spotted it. On a task that had been open for weeks, with dozens of comments from several people and an agent, that could mean a lot of scrolling for one sentence you half-remembered.

Now you can search by a word or phrase, or by who wrote it, and narrow further to only unresolved threads, only resolved ones, or only your own. Clicking a result jumps the page straight to that comment, already in view.

How It Works

• A search field in the task's header matches comment text and author name as you type.
• Filter options let you view All, Unresolved, Resolved, or Mine so you can focus on what still needs attention.
• Selecting a result scrolls the thread directly to that comment.
• Threads can be marked Resolved right from the comment, and reopened the same way, so a settled discussion is visibly out of the way without leaving the task.

Where to Find It

The thread finder is available now in both the full Task view and the Task modal, on every project, with 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 a command from the Effigate CLI was rejected, it used to show only a generic error code — one that read as "try again," even when retrying could never work. It now shows the actual reason, in plain language, so you know exactly what to fix.

What You Gain

A generic failure code doesn't tell you whether a request failed because of a typo, a naming clash, or something that will never succeed no matter how many times you run it. That ambiguity led to retrying requests that were doomed to fail every time.

Now a rejected request explains itself: for example, "an agent with this name already exists," or "this task is already assigned to someone." When the problem is a specific field you got wrong, that field is named directly, so you can fix it in one pass instead of guessing.

How It Works

• Error responses now show the real, specific reason a request was rejected, not just a generic failure code.
• Validation errors name the exact field that needs to change.
• A rare case where the server itself returns an unreadable error (for example, from a network issue) now shows as a clear failure message instead of crashing the tool.

Where to Find It

This applies automatically to every command in the Effigate CLI — nothing to configure.

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

Summary

Two changes make staged sub-tasks genuinely easy to use. Assigning a parent task now offers to assign its sub-tasks at the same time, held back until their stage's turn — and once a stage finishes, the next one starts on its own.

What You Gain

Before this, assigning an agent to a sub-task started it working immediately. So assigning a multi-stage breakdown one sub-task at a time ended up starting every stage at once, with nothing held back for later — defeating the whole point of staging the work.

Imagine a breakdown with five sub-tasks across three stages. Now, assigning the parent task asks a simple question first: assign all five sub-tasks too? It shows you exactly how they're grouped — for example, two in stage one, two in stage two, one in stage three — so you can see the shape of the whole run before committing. Choose to assign them all, and every sub-task gets the same agent and waits its turn; the stage order decides what runs when. Choose "this task only," and nothing else is touched.

How It Works

• Assigning a parent task with sub-tasks offers to assign the whole breakdown at once, broken down by stage so you know what you're agreeing to.
• Sub-tasks that are already finished are never reopened by this, and sub-tasks of sub-tasks are included.
• Once a stage's work is complete, the next stage now starts automatically — nobody has to manually promote it, so a breakdown can't stall on a missed step.
• Only the very next unfinished stage is released at a time; later ones stay parked until their turn.
• A record of what was assigned is kept on the task's activity, so the change is visible to your team.

Where to Find It

Available now on every project using sub-task stages — just assign the parent task and answer the prompt.

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

Summary

When AI Chat suggests several tasks that are really one piece of work, it now presents them as a structured breakdown — linked to a parent and ordered into stages — instead of a flat list you'd have to organize yourself. It also now remembers what it has already proposed.

What You Gain

Previously, a suggestion covering several related pieces of work came back as separate, unconnected items, leaving you to work out which depended on which and reassemble the structure yourself. A flat list of genuinely independent suggestions is unaffected and still arrives that way.

AI Chat also used to forget its own suggestions between messages — because only the written-out text of the conversation was being used to remember what happened, not the structured plan itself. That meant it could lose track of which tasks you'd already confirmed or skipped, and suggest the same ones again. It now retains that context properly, so it won't re-propose work it already created.

How It Works

• A multi-part suggestion arrives linked to its parent and already ordered into stages, so a staged breakdown runs stage by stage once you assign the parent, rather than all at once.
• AI Chat now remembers exactly what it proposed, what you confirmed or skipped, and the identifiers of anything it created — so it won't repeat itself.
• The AI Chat inside an individual task — the one you use for feedback, voice notes, or screenshots — gets the same improvement: unrelated suggestions now stay separate instead of all being nested under the first one.

Where to Find It

This applies automatically everywhere AI Chat proposes tasks — in the main chat and inside individual tasks.

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

Summary

The standing instructions handed to an agent at the start of every run included guidance that didn't apply once a project was already set up — or, for chat runs, didn't apply at all. That's trimmed now, leaving more working room for your actual request.

What You Gain

Every bit of unnecessary instruction text an agent reads is room it doesn't have for your actual task. On a project that already had its groundwork laid, agents were still being handed guidance meant only for brand-new projects — reducing the space available for the real work on every single run.

Instructions are now sized to what's actually needed: around 18% shorter on an established project, and 26% shorter for chat runs, which never needed that guidance at all.

How It Works

An agent now only receives setup guidance for a project when that project genuinely still needs it. Projects that already have their groundwork written skip that section entirely, and chat runs, which never involve a project repository, skip it too.

Where to Find It

This applies automatically to every agent run and chat — 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 replies inside a shared Slack channel rather than a one-to-one message, it's now told that other people can see what it writes — so it treats a group conversation differently from a private one.

What You Gain

An agent that didn't know who else could read its reply had no way to adjust its tone or the detail it shared for a wider audience. Now it's explicitly told whether a conversation is direct, shared with a group, or of a shape it can't confirm — and in that last, uncertain case, it's treated as potentially shared rather than assumed private, so it's never careless with something that might not be a one-to-one chat. This builds on talking to your agents directly from Slack.

How It Works

An agent now checks the shape of a Slack conversation before replying: a direct message, a shared channel, or a conversation it can't confirm the shape of. In that last case, it's treated as potentially shared rather than assumed private, so it never tells itself a reply is confidential when it might not be.

Where to Find It

No setup is needed — this applies automatically wherever an agent is connected to Slack.

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

Summary

When a task was too large for a single agent run to hold in its working memory, the run used to be marked complete even though nothing had actually been done. It now fails with a plain explanation of what happened and what to do next.

What You Gain

Before this fix, a run that ran out of room would quietly report "finished," which looked exactly like success — so you could believe a task was done when it wasn't, sometimes for a while before noticing. Now you see immediately when a task was too big for one run, with a clear next step: split the work into sub-tasks, or start a fresh run.

How It Works

These runs are not retried automatically, since simply running the same request again hits the same limit, and no pull request is opened for a run that produced nothing. The failure message tells you directly what went wrong, so you can decide how to re-scope the work.

Where to Find It

This applies automatically to every agent run — no setting to change.

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

Summary

Fixed an issue where agents running on Windows couldn't find a command-line tool they needed, which could leave a run stuck.

What You Gain

Runs on Windows machines now start and finish reliably instead of occasionally hanging while an agent searched for a tool that wasn't where it expected.

How It Works

This is a behind-the-scenes fix for the desktop app on Windows; nothing changes in how you work.

Where to Find It

Already live for every Windows desktop app install.

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

Summary

The right-hand properties panel on the task window was rebuilt at a tighter density, fitting noticeably more of a task's details on screen without scrolling.

What You Gain

Previously, checking several of a task's properties at once often meant scrolling the panel. Now more of them fit at once, while each section still reads clearly on its own.

How It Works

This is a visual refinement — the same properties, organized more efficiently.

Where to Find It

Visible on every task's properties panel today.

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

Summary

The remaining pages in Effigate Command Center finished moving onto the same modern, faster framework the rest of the product already used, along with a batch of small reliability fixes along the way.

What You Gain

Pages that hadn't yet made the move could feel a step behind the rest of the app — slightly slower, or inconsistent with how the newer pages behaved. With this migration complete, every page in the product now shares the same fast, consistent foundation.

How It Works

This is a behind-the-scenes change: the pages you use look and work the same, just faster and more consistent, with a handful of loading and notification glitches fixed along the way.

Where to Find It

No action needed — this applies across the whole product automatically.

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

Summary

Agents are now reachable from Slack: DM one directly, @-mention it in a channel, or file a new task with a simple command — connected either through a public link or through a mode that needs no public URL at all.

What You Gain

Before this, getting an agent to do something meant opening Effigate Command Center itself, even if the conversation that prompted the idea happened in Slack. Now the gap between "we were just talking about this in Slack" and "an agent is working on it" disappears.

Picture a team discussing a bug in a shared channel: instead of someone switching tools to file and assign a task, anyone in that channel can @-mention the agent right there, or use a simple command to turn the conversation into a tracked task — the agent picks it up without anyone leaving Slack.

How It Works

• Direct messages. DM an agent privately the same way you'd message a teammate.
• @-mentions in a channel. Bring an agent into a group conversation by mentioning it, and it responds in context.
• A quick task command. File a new task straight from Slack with a simple command, no need to open the app.
• Two ways to connect. Set it up with a public link, or with a mode that needs no public URL at all — useful for teams that can't expose one.

Where to Find It

Set up the Slack integration from your workspace settings; once connected, every teammate in your Slack can start using it immediately. This builds on connecting Slack for your agents — the same connection now reaches you back, not just the other way around.

Read the full setup guide and see what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to connect your own Slack.

Summary

A batch of Sprint and Task improvements landed together: a Sprint dropdown on the Task form, smarter default sorting for active work, visible overdue highlighting, and an editable task Weight with an explanation of how it affects sprint progress.

What You Gain

Finding and managing active work used to take a bit more digging — scrolling to find the active sprint, spotting which tasks were overdue, or figuring out why a task's Weight mattered. Now the Active sprint and Unscheduled section open and sort to the top by default, overdue tasks are visually flagged, and Weight is right there in the Task modal with a plain explanation of what it does to sprint progress.

How It Works

• A Sprint dropdown on the Task form lets you assign a sprint without leaving the task.
• Smart defaults expand the Active sprint and Unscheduled section first, sorted to the top.
• Overdue highlighting makes late tasks visually obvious inside a sprint.
• Editable Weight, visible in the Task modal, with an in-app note on how it factors into sprint progress.

Where to Find It

All available now on every project's Sprints and Task views.

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

Summary

Clicking outside the task window now closes it reliably, without the old bug where picking a file attachment accidentally closed it too. The Token Usage panel now shows for any task an agent has worked, not only finished ones.

What You Gain

A couple of small annoyances are gone: losing your place because an attachment picker closed the task, and not being able to check usage on work still in progress.

How It Works

These are small behavior fixes; the task window works the way you'd expect it to now.

Where to Find It

Already live for everyone.

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

Summary

When one agent works through several tasks in the same project one after another, each new task now correctly builds on the previous one's still-open work instead of starting from an outdated point — so they no longer conflict.

What You Gain

Before this fix, if an agent picked up a second task in the same project while the first task's work was still open, the two pieces of work could end up conflicting with each other, creating extra cleanup. Now each new task in that sequence picks up from where the agent's previous task actually left off, so the work stacks cleanly instead of colliding.

How It Works

This runs automatically whenever one agent works through back-to-back tasks in the same project — no setup needed, and nothing changes about how you assign work.

Where to Find It

Applies to every project and agent today.

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

Summary

Quick Actions let you save a reusable agent-and-prompt pair and fire it at any task in a single click, straight from a task's menu or its properties panel.

What You Gain

Before Quick Actions, running the same kind of request against a task — "summarize this," "write tests for this," "translate this" — meant picking the agent and typing out the same prompt every time. Now you set it up once and reuse it everywhere.

Picture a team that regularly asks an agent to write a changelog-style summary of any finished task: instead of retyping that prompt each time, they save it once as a Quick Action, and from then on it's one click away from any task's menu.

How It Works

• Save a pair. Combine a specific agent with a specific prompt and give it a name.
• Run it from anywhere. Trigger a Quick Action from a task's "..." menu or its properties panel.
• Manage them centrally. Create, edit or remove Quick Actions from Settings → Quick Actions.

Where to Find It

Set up your first Quick Action under Settings → Quick Actions; available to every account.

Read the full guide and see what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center.

Summary

Once every sub-task under a parent task reaches Done or Cancelled, the parent now gets a summary comment of what finished, and its agent is automatically re-triggered to pick up where things left off.

What You Gain

Previously, a parent task with sub-tasks assigned to an agent could sit idle once those sub-tasks wrapped up, with nothing prompting the parent to continue. You'd have to notice yourself and nudge it along. Now the parent is nudged automatically the moment its last sub-task closes, with a comment summarizing what was done.

How It Works

This applies whenever a parent task is assigned to an agent, isn't parked as Open, and isn't already closed — its agent picks the work back up as soon as every sub-task finishes.

Where to Find It

Works automatically on any qualifying parent task — nothing to configure.

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

Summary

An agent can no longer mark its own task Done — that now takes a human approving the work, or its pull request actually merging. Every run also now leaves a result comment, and comment replies notify the person being replied to.

What You Gain

Previously, it was possible for an agent's own judgment about "done" to be the only thing closing out a task, with no guaranteed human checkpoint and no guaranteed comment explaining what happened. That left room for a task to close without anyone having actually looked at the result.

Now closing a task always means one of two things happened: a person reviewed and approved it, or the change actually shipped through a merged pull request. And you'll always get a comment explaining what a run did, even if it finished without saying anything itself.

How It Works

• Only humans or merges close tasks — an agent's own assessment is no longer enough.
• A result comment is guaranteed on every run, even a silent one.
• Reply notifications now reach the specific person being replied to, not just the thread.

Where to Find It

Applies automatically to every task and every agent — nothing to configure.

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

Summary

The @mention picker in comments now also lists tasks, not just people — and any task you reference turns into a clickable link right in the conversation.

What You Gain

Before this, pointing someone to a related task inside a comment meant copying a link or describing it by name, with no guarantee the reader could find it easily. Now typing @ and a task's name drops in a live reference anyone can click straight to that task.

How It Works

• Type @ in any comment to search tasks alongside people.
• Referenced tasks become clickable links, highlighted in the comment thread so they stand out.

Where to Find It

Works everywhere comments already do — no setup required.

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

Summary

Each tab inside a project — Sprints, Backlog, Documents, the project brief, Resources — now has its own real, bookmarkable URL instead of jumping to a generic project link.

What You Gain

Previously, sharing "the Backlog for this project" with a teammate meant sending the whole project and asking them to click the right tab themselves. Now you can copy the exact link to the tab you're looking at and send that directly.

How It Works

Navigate to any project tab and its address bar URL updates to match — bookmark it, share it, or use back and forward like any other page.

Where to Find It

Works automatically across every project, on every account.

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

Summary

Creating a new sprint now opens in a focused modal window instead of an inline form on the Sprints tab.

What You Gain

The inline form could feel cramped and easy to lose track of while scrolling. The modal keeps sprint creation front and center until you're done.

How It Works

Click to create a sprint and it opens in its own window; fill it in and close it, same fields as before.

Where to Find It

Available now on the Sprints tab of every project.

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

Summary

Project Members and Admins no longer need to claim a task before commenting on it, and comment threads can now be sorted latest-first or oldest-first.

What You Gain

Before this, leaving a quick comment on a task you weren't assigned to could be blocked until you claimed it — awkward for a manager or teammate who just wants to weigh in. And a long comment thread only ever read in one order, whether or not that suited you.

How It Works

Comment on any task you have access to, claimed or not; choose how the thread sorts from the comment view.

Where to Find It

Available on every task today, for every Project Member and Admin.

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

Summary

Reviewing a task's work is simpler now: the old three-button review card in the middle of the task has been replaced by Approve and Close & Reassign in the task header, and "Request changes" is now a Feedback to agent checkbox you can use at any status.

What You Gain

The previous review card only appeared during a specific review step, and its three options could blur together. Now the two clearest outcomes — approve, or close and hand to someone else — live right in the header where you're already looking. And feedback for an agent is no longer locked to one stage: check the Feedback to agent box on any comment, at any point, and it reopens the task and re-queues the agent with your note.

How It Works

• Approve or Close & Reassign, right in the task header, replacing the old mid-task card.
• Feedback to agent is a checkbox on the comment box, usable at any status — not just during review.
• Sending feedback reopens the task and re-queues its agent automatically.

Where to Find It

Available on every task today — no setup required.

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

Summary

Your inbox now lets you mute notifications by category — assignments, status changes, comments and mentions, priority and due dates, or agent activity — and new items can also show up as a native browser banner, even when the tab isn't in front of you.

What You Gain

Before this, notifications arrived as one undifferentiated stream: every assignment, comment, status change and agent update landed the same way, whether or not you cared about that particular kind of update. If you only wanted to know about mentions and comments, you had no way to quiet the rest.

Now you can turn each category up or down on its own. Picture someone who manages a dozen agents but only needs to know when a human mentions them directly: they can mute status changes and agent activity, keep comments and mentions on, and still catch anything urgent the moment it arrives as a browser banner, without needing the tab open.

How It Works

• Five notification groups — Assignments, Status changes, Comments & Mentions, Priority & Due date, and Agent activity — each with its own on/off switch.
• A dedicated settings page under Settings → Inbox Notifications lists every group in one place.
• Native browser banners for new inbox items, so you can notice something important without keeping the tab active.

Where to Find It

Open Settings → Inbox Notifications to choose what reaches you; browser banners ask for your permission the first time.

See what else shipped that month on the Effigate Command Center changelog, or try Effigate Command Center to set up your own notifications.

Summary

Fixed two reliability issues: a task created from the Board sometimes didn't appear without a manual refresh, and a connection problem that could silently stop live comment updates.

What You Gain

Both issues are now fixed — new tasks appear on the Board right away, and comments update live without needing a refresh to catch up.

How It Works

These were behind-the-scenes connection fixes; there's nothing new to learn, just a Board and comment thread that now keep up on their own.

Where to Find It

Already live on every account.

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

Summary

A round of fixes landed for the Board and tasks: smoother drag-and-drop, more reliable task transcripts, a fixed assign-to picker, and several inbox issues cleared up.

What You Gain

Small but real friction points — a drag that didn't behave at the edges of the board, a transcript that didn't always show, an assignment picker that misbehaved — are gone.

How It Works

These are behind-the-scenes fixes; nothing changes about how you use the Board or tasks, except that it now works as expected.

Where to Find It

Already live on every account.

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

Summary

Merging a task's pull request on GitHub now moves the task to Done and notifies the assignee, managers, and your connected Slack — the same as approving it from inside Effigate Command Center.

What You Gain

Previously, approving work directly on GitHub, rather than inside the product, didn't carry the same notifications as an in-app approval, so teammates might not find out a task was done until they checked manually. Now both paths behave the same way.

How It Works

Merge the pull request on GitHub as you normally would; the task moves to Done and the same notifications go out as if you'd approved it in Effigate Command Center.

Where to Find It

Works automatically for every project connected to GitHub.

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

Summary

Effigate Command Center now has a full Help Center built into the product itself, with search, a navigation sidebar and screenshots for every guide — and a Help entry in the main sidebar for everyone.

What You Gain

Before this, getting an answer about how something worked meant leaving the product, searching elsewhere, or asking a teammate. Now the documentation lives exactly where you're already working, a click away in the main sidebar, with search that gets you to the right guide quickly instead of scrolling through a long list.

How It Works

• Built-in search finds the guide you need without leaving the app.
• A navigation sidebar organizes every guide by topic.
• Screenshots throughout show exactly what you're looking for, not just describe it.
• One click away from anywhere in the product, via the new Help entry in the main sidebar.

Where to Find It

Click Help in the main sidebar from any page — available to everyone on every account.

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

Summary

Alongside the standard Kanban board, projects now offer a swimlane view — grouping tasks into horizontal rows so you can see work broken out by category at a glance.

What You Gain

The standard board is great for seeing status at a glance, but it doesn't show how work breaks down by team, type, or owner without extra digging. Swimlanes add that second dimension: the same tasks, now also grouped into rows that make patterns easier to spot — for example, seeing at once that one team's lane is piling up while another's is empty.

How It Works

Switch to the swimlane view from the board's view selector; tasks keep their normal status columns, now also grouped into the rows you choose.

Where to Find It

Available on every project's Board today, alongside the existing Kanban view.

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