An AI Dev Team in Your Pocket: Multi-Agent Coding with AI Office

Most "AI in your IDE" means autocomplete and a chat box. Useful — but it's still you doing the orchestration: deciding what to build, splitting it into steps, wiring the pieces, and checking the result.

PocketCode's AI Office flips that. You write a brief in plain language, and a team of specialized AI agents plans it, breaks it into tasks, executes them with real tools, and reviews its own work — while you watch. On your phone.

From a sentence to a working session

You start in the Lobby, a four-step wizard:

1. Basics — pick a template (or none), name the project, optionally link an existing project so the agents study it first.
2. Description — the brief: what you want the office to do.
3. Team — toggle which roles join.
4. Advanced — choose a workflow, Quick Mode, parallelism, sprint and token budgets, and which AI provider to run on.

Hit Start and the office goes to work: it analyzes complexity, may ask you a couple of clarifying questions, and produces a plan you can review and edit before anything runs.

The team: eight specialists

AI Office isn't one model pretending to be many. It's eight distinct roles, each with its own skills:

Role	Focus
Project Manager	Planning, decomposition, prioritization (always leads)
Architect	Architecture, system design
Frontend Dev	UI, layouts, animation, theming
Backend Dev	APIs, repositories, use cases, networking
QA Engineer	Testing, code review, debugging
DevOps	Build, deploy, terminal, git
Tech Writer	Documentation, READMEs, comments
Data Engineer	Databases, SQL, migrations

The Project Manager is always on the team — it's the one that turns your brief into a plan and coordinates everyone else.

Nine ways to work

The workflow decides the phases and how agents hand off to each other. You pick one, or leave it on Auto and the office infers it from your brief:

• Feature — plan, implement, verify, document a new capability
• Bug-fix — triage, root-cause patch, regression checks
• Refactor — improve structure while preserving behavior
• Performance — measure, optimize, verify a real gain
• Security review — audit sensitive flows, permissions, secrets
• Docs — write or update developer documentation
• Release — run checks, prepare notes, organize artifacts
• SPARC — the five-phase method (Specification, Pseudocode, Architecture, Refinement, Completion)
• Auto — let the orchestrator choose based on keywords in your brief

A real plan you approve

Before execution, the PM produces a sprint-aware plan: it rates the project from Trivial to Massive, then decomposes it into tasks — each with an assignee, dependencies, target files, acceptance criteria, a risk level, and an effort estimate. The Plan Review screen is fully editable: retitle tasks, change priorities, add or delete tasks, or send feedback to re-plan. Nothing runs until you press approve.

Watching the office work

Once running, four views let you follow along (and steer):

• Office Floor — a visual map of the team. Each desk shows an agent's avatar, role, live status (idle / thinking / working / reviewing) and what it's doing right now, with a pulse while it works.
• Task Board — a Kanban with six columns: Backlog, Todo, In Progress, In Review, Done, and Failed/Blocked. Cards carry the assignee, priority and risk.
• Chat Log — the unified feed of inter-agent messages and tool activity ("Tool TERMINAL executed: git status"). You can type directives here — the orchestrator interprets them as re-plan, skip a task, change priority, add a requirement, reassign, pause or resume.
• Results — tasks completed, tokens used, duration, success rate, plus a per-agent roster and a task-by-task outcome list.

Agents that actually do the work

This is the part that separates AI Office from a chat that only writes text. When an agent executes a task, it can call ten real tools:

Tool	What it does
Terminal	Run a shell command
File read / create / edit	Read, create, or patch files in your project
Database query / schema / list tables	Run SQL and inspect the schema
HTTP request	Call any endpoint
SSH exec	Run a command on a remote host
Git	status, diff, commit, push…

Every tool call and its result are recorded, so the Chat Log is a real audit trail of what the office did — not just what it said.

It keeps working after you close it

When you archive a session, seven background workers run in sequence:

• Security audit — hardcoded secrets, injection, insecure APIs, path traversal, data exposure
• Test gaps — functions and complex logic left without coverage
• Documentation — a README-style summary of what was built
• Memory consolidation — deduplicates the session's memory
• Dependency map — how the generated files connect
• Optimize and Refactor — suggestions for later

Their findings are saved as memory and injected into future sessions on the same project — so the office gets to know your codebase over time. A checkpoint system also survives crashes: reopen a session and it resumes from where it left off.

Save the result as a real project

After a session completes, AI Office can persist the deliverables: it finds the code blocks in the task results, creates (or reuses) a project, writes the files, and generates a README with the summary.

What's free — honestly

The whole system is free to run: the wizard, all eight roles, the nine workflows, the ten tools, project templates, background workers and memory. And so is every AI provider — it is all BYOK (bring your own key):

• Gemini, OpenAI, Anthropic Claude and GitHub Copilot — connect your own account or API key (PocketCode charges nothing; the provider bills you).
• Any OpenAI-compatible endpoint via the Custom provider: OpenRouter, a local Ollama (offline, no key), or your own server.

So a free user can hand a brief to a full AI dev team and watch it build on any model they like — even one running locally for nothing. The paid tier is for our own tools (like Swarmcode) and cloud sync, never for model access.

Working on something small? Quick Mode skips the clarifying questions and auto-approves the plan for trivial and simple tasks, so you go from brief to build in one tap.

---

Autocomplete guesses your next line. AI Office plans the whole thing, splits the work across specialists, runs real terminal, git and file operations, reviews itself, and hands you a project — from a phone.

PocketCode is heading to Google Play. Join the pre-registration to put an AI dev team in your pocket.