The AI development environment inside your portal
Not an editor with a model bolted onto the side. Companion opens a project from the portal, pulls its context out of the Wiki pages, takes the tasks you hand it off the board, and does the work with several agents at once. The status, the outcome in the card and the hours go back to the portal through that same channel — from the tab you are driving.
- Native in Projects, Wiki and tasks
- As many agents in parallel as the work needs
- Who worked, when and how long — recorded
Task from the board
DEV-418 · Session is not extended after a token refresh
MCP · Wiki
2 pages from the “Platform” space added to the context
npm run check
0 errors
MCP · Projects
DEV-418 → Done, comment added
DEV-418
DoneSession is not extended
Companion
Session refresh fixed, checks green. Moved it to Done.
Recorded for the day
- Agent time
- 38 min
- Commits
- 3
- Lines
- +128 / −54
Companion — a marketplace module: it is added to a suite you already use, and is not sold on its own.
Not an integration with the portal. The same portal
Companion reaches the platform through the platform’s own MCP server — the same one Claude Code, Cursor, Windsurf and VS Code connect to. 142 tools in 13 groups, with the permissions of whoever opened the tab and no more. So "fetch the task", "read the wiki page" and "move the task to another status" are ordinary calls, each shown in the chat as its own card.
Projects
15 MCPOpens the project, reads the board, takes a task into work, moves its status and leaves the outcome in the card when the work is done. Team tasks work the same way.
Wiki
8 MCPPulls the space’s pages in as context — the decisions, agreements and standards that are not in the repository.
Test management
26 MCPReads the test cases and plans your QA team wrote, and checks the work against them.
Team tasks
12 MCPTakes tasks from a team space, comments on the card, and never grabs what another worker already holds.
Personal tasks
5 MCPSees your personal tasks and leaves its trace in the same place you put them.
Client Portal
3 MCPThe client ticket stays the same record from request to release — nothing is retyped into a second system.
Chat
16 MCPFinds the agreement in the channel where it was made, instead of somebody’s recollection.
CRM
19 MCPKnows who the work is for: the company, the deal, the history of requests.
Projects, Wiki and tasks have their own screens in the cockpit. The rest of the platform is reachable — the agent has those tools and your permissions — but there is no dedicated button for them.
Every MCP call is a card: what was called, with what, and what came back.
From a task on the board to a status of done — through the same channel
This is not a slide-deck scenario: it is how this site and the portal itself are built, day to day. Most of the steps stay yours — the machine does the middle — and none of them needs a second tool.
- 01 You
You pick the project in the portal
A project from Projects is bound to a folder on disk. The tab knows which tenant and team it belongs to before the first word is typed.
- 02 You
You add wiki pages as context
You find the pages you need in the space, and the agent reads them as part of the brief. The standard, the decision that was made, the domain description: the things the code does not contain and never will.
- 03 You
You take named tasks off the board
You point at what to take — from the project board or a team space. Each task gets its own tab, so parallel jobs do not tread on each other and each keeps its own history.
- 04 Companion
Companion works it out and does it
It reads the code, pulls the context, plans, edits and runs the checks. Every command and every MCP call is a card in the thread, and the phase strip in the header says which step the work is on.
- 05 Companion
The status and the outcome go back to the portal
Through the same MCP: the task moves to the status it belongs in, and a comment lands on the card saying what was done. Nobody retypes the result into the ticket. Two limits are deliberate: a status that emails the client is never moved from Companion — that one stays in the portal — and in factory mode the outcome comes back as the master’s comment, with the column left for you to move.
- 06 You
You look at the result, not at the process
A report in the tab, the diffs under Changes, the test cases checked. And in the portal, a record of who worked on it, when, and for how long.
One tab, one agent. As many tabs as the work needs
When the work splits into independent chunks, a tab can be promoted to master: it spawns its own workers, hands them tickets from the queue, skims what each has just produced, wakes the ones that went quiet and kills the ones that went wrong. The master itself stops writing code — its job is to hand out and to check.
- Queue from the board
- Tickets come off the project or team board — only those carrying the agent-ready label, and each goes to exactly one worker. What is not labelled is not touched: the master names it rather than working on it behind your back.
- Tab groups
- A dozen agents fold into a named group. Collapsed, it still shows how many are waiting for you, how many are working and how many failed.
- The factory reports; it does not decide
- In the factory pipeline a worker’s artefact is text: it does not write to the card itself. The master publishes the outcome, and it is the master that is barred from touching the ticket’s status — in this mode the column is yours to move.
- Nothing hangs
- A worker whose process died is marked failed, not left "working" forever. A master that goes quiet is nudged after 5, 5, 10, 10 and 15 minutes, then every half hour.
- The right engine per task
- Claude, Grok, Codex, Kimi or MiniMax — on your own key with that provider. We do not resell inference: where the CLI reports a price the tab shows it, and where it cannot count honestly it shows a dash rather than an invented number.
- DEV-418 · auth working
- DEV-421 · billing working
- DEV-402 · imports needs you
- DEV-399 · tests done
- DEV-425 · docs queued
Collapsed, the group still shows the same three numbers: waiting for you, working, failed.
Who worked, when and how long — with nobody filling in a timesheet
Every working session — human and agent alike — becomes an event: device, project, start, end, duration. Alongside the time go counters from the repository’s own log: commits, lines added and lines removed that day, with the commit author’s email. All of it rolls up into daily per-project totals and syncs to the portal, so the cockpit and the portal count the same agents the same way. This is not screen surveillance: no screenshots, no keystrokes — only what was worked on, how long it took, and what came out of it in the code.
ACME Platform · this week
Daily totals, as the portal sees them
- Mon 3h 34m
- Tue 6h 26m
- Wed 4h 58m
- Thu 7h 11m
- Fri 2h 56m
Time by project
Daily totals per project and per device, which survive a restart and an app update.
Limits and cost
The session and weekly percentages come from the provider account, not from a cache; when a number is cached, it says so.
What a tab is carrying
The context window is metered with hints at 200K, 400K and 600K — and it says when the model has compacted it on its own.
People, agents and peak concurrency
The daily total keeps human time, agent time and autonomous-agent time apart, along with how many agents ran and how many were running at once at the peak.
Whose name it lands under
The write goes out with the permissions of whoever opened the tab, so the card records the change under a person. The comment is signed by the agent — you can see who is accountable and who did the work.
The dispatcher log
When something goes wrong there is something to read: the dispatcher writes its decisions to a log, and a report goes out from one item in the app menu.
What you see, and what you steer
Everything the agent does is visible as it happens rather than afterwards. Commands and file changes also ask permission; MCP calls arrive as cards — a receipt rather than a gate.
The phase strip
P.G.B.R.Q.S. in the chat header — which step the work is on, without reading the thread.
Every command is visible
Shell commands and MCP calls arrive as cards with their result, instead of hiding behind "done".
File tree and editor
The right column shows the project, files are edited in the cockpit itself, and deletions go to the system Trash.
Changes and terminal
Branch diffs in their own tab, the branch and worktree on a badge, and a shell command in a reply runs from a Run button.
Cards, not a wall of text
A report, a question with options, a QA plan and its result, design previews — each its own card, answerable with a click.
Voice, images, search
Dictation with a language picker, a screenshot pastes straight into the chat, and search runs across the whole project.
What stops being needed
- Copying a task from the board into a chat with a model
- Retelling the company’s context in your own words every time
- Moving statuses by hand after the work is already done
- A timesheet somebody fills in from memory in the evening
- A test-management tool the agent cannot see
This page was built in Companion
The task came off a board in the portal, the context came from wiki pages in the same space, the work ran in several tabs at once, and the status and the outcome went back through the same MCP. We will walk you through it on a call — on your project, not on a demo one.
Runs on the shared memory — Synapse
Everything done in Companion leaves a trace in the shared company memory: tasks, decisions, diffs and checks become context the rest of the platform reads from. This is the same memory Synapse answers from and Command Center runs on. The memory comes with every paid plan, and its size is set by the plan you are on.