Repos, provider credentials, prompts, logs, and thread output stay on your Mac by default.
Local-first agent command center
Supervise Codex and Claude work across every repo.
Asyncly routes each request to the right local workspace, keeps every agent thread visible, and turns blocked output into the next executable step — without giving up local approval control.
create account / download Mac app / connect Codex or Claude / add workspace / run first task

Connect both providers, watch live status, and switch a thread between them without losing context.
Create an account, start a no card 30-day trial, download the Mac app, and sign in to start working.
Product flow
One request becomes routed, supervised work.
As you scroll, the same desktop app moves through how Asyncly handles a request: command in, route to a workspace, supervise the running thread, and review the result locally.
Start with the thing you actually need done.
Type or speak one natural request instead of choosing a repo, finding the right terminal, and rebuilding context from memory.
Asyncly finds the right workspace and thread.
The manager uses local workspace context and active thread state to send the work where it belongs.
Every agent thread stays visible.
Running, blocked, needs-review, and done work stays in one surface without flattening separate projects together.
Approvals and next steps stay local.
Asyncly turns stalled output into a follow-up prompt and review gate before risky changes move forward.

Thread Map and file peek
Turn busy agent work into a navigable workspace map.
Map view gives a crowded workspace spatial memory: groups, thread clusters, zoom controls, and Auto group keep related work together. From any thread, changed files can open in a read-only preview so review stays attached to the work that produced it.
Threads can be arranged by feature, risk, client, provider, or phase. That makes Asyncly feel like a real operating layer for builders managing many agents at once.
function modalThreadLayoutsForCompany(companyId, layouts = modalThreadLayouts) { const filteredLayouts = new Map(); const activeLayoutIds = activeCompanyId === companyId && !elements.companyModal?.classList.contains("hidden") ? new Set(currentModalThreadOrderIds()) : new Set(); layouts?.forEach((layout, itemId) => { const itemCompanyId = companyIdForModalThreadLayoutItem(itemId); const normalizedLayout = normalizeModalThreadLayout(layout); if (!modalThreadLayoutHasPersistedState(normalizedLayout)) return; filteredLayouts.set(itemId, normalizedLayout); return filteredLayouts;}Operator depth
Advanced controls stay visible when the work gets complex.
Asyncly does not just start an agent and disappear. It keeps provider choice, code-health playbooks, git state, and thread context close to the task so follow-up work starts with less rediscovery.
Find shared-file risk and bloated surfaces.
Choose bounded cleanup that stays low-risk.
Produce a reviewable task sequence.
Stop before risky execution.
Apply scoped changes only after approval.
Use thread #5 and the Setup Skills notes to continue the homepage build.
Mobile remote supervisor
A window back to the Mac, from your phone.
The Mac stays the executor and source of truth. From the phone you start tasks, follow thread state, approve work, and review the visual captures the Mac generates.
Private beta while pairing, relay, notifications, and mobile task review are validated end to end.
Local repos, provider sessions, visual captures, and thread state stay on the Mac.

Local trust boundary
Local-first by default. Connected only where the product needs it.
Asyncly services handle account, billing, entitlement, release, and support metadata. Your repos, provider credentials, prompts, logs, and task outputs stay local unless you explicitly connect an integration.
Start local, run your first task in minutes