Do Three Agents Finish Sooner? Count the Integration Time A Kilo Desktop guide argues that teams measuring whether parallel coding agents save time must count integration time, not just agent completion: three agents finishing patches in ten minutes plus twenty minutes of combining and repairing yields a 30-minute total that must be compared against a sequential run. The guide recommends running each agent in its own Git worktree from a shared baseline commit, giving each identical briefs, model settings, tool access and test data, and timing from session preparation through final review, with five repetitions per condition if budget allows. Kilo Desktop's worktree-based sessions are positioned as the way to keep concurrent agents from editing one another's files. Measure when the combined work is ready Suppose three agents finish their assigned patches in ten minutes, but you spend another twenty combining and repairing the changes. To decide whether parallel work saved time, you need to compare the full thirty minutes with a sequential run. Stopping the clock when the agents finish leaves out the work you still have to do. Kilo Desktop https://kilo.ai/install desktop lets you run separate sessions in new or existing Git worktrees, giving each agent its own working files from a chosen base. You can use those isolated copies to compare concurrent and sequential attempts without agents editing one another’s files Kilo Desktop quickstart https://kilo.ai/docs/desktop/quickstart . Use independent tasks with a shared final acceptance check. Measure completion only after you have combined the patches and reviewed the application, so coordination time counts in both runs. Divide the work by dependency For this exercise, use a demo application with a help page, reports page, and search dialog. Assign an expandable FAQ to one agent, CSV export to another, and a search shortcut to the third. Each result should work independently of the other agents’ implementation choices. Supply the FAQ’s exact questions and answers and require keyboard-operable controls. For CSV export, identify the rows and column order, including how to escape commas, quotes, and line breaks. Define the search shortcut and require it to remain inactive while someone types in a form field. Give every agent the starting commit, its allowed files, existing components to reuse, and the required checks. Keep dependencies fixed and require the agent to report any necessary change outside its assigned area before making it. If every task needs a change to the same shared component, settle that component’s interface before starting. Separate worktrees will not resolve a design decision that all three implementations depend on. Prepare separate worktrees and shared expectations Preserve unrelated work and commit a clean baseline. In Kilo Desktop, choose the workspace and use its Git controls https://kilo.ai/docs/desktop/features/git to create a worktree from that baseline for each task. Name sessions after their assignments so you can tell which one needs attention. Use the same model and reasoning settings for both conditions, along with identical briefs, tool access, dependencies, and test data. Record any installation or preparation each worktree requires as part of the setup time. Check resources outside the working files. Assign different ports to development servers, and keep tests from writing to the same database or output directory. Disposable fixtures help prevent one session’s test data from affecting another’s results. Choose one person or authorized review step to integrate the patches. Ask each task agent to report its changes and test results without merging the other agents’ work. Compare one active session with three For the sequential run, complete the task sessions one after another, starting each from the original base commit. For the parallel run, launch the same sessions together in separate worktrees. This gives each task the same starting files in both conditions. This setup measures whether concurrency helps with independent tasks. Comparing it with one continuous conversation would answer a different question, because that conversation could carry knowledge and changes from one task into the next. Start the clock before preparing the first session and stop after integration and final review. Record preparation, waiting, active supervision, integration, and verification separately to see how each contributes to completion time. If your budget allows, repeat each condition five times from clean workspaces. Alternate which condition runs first and use the same integration order. Note throttling and network interruptions, along with local resource limits that may explain a delay. Test the combined application Keep the task outputs intact and integrate their patches into a separate branch or workspace. Review scope before applying each patch, especially when an agent has changed shared styling or other code outside its assignment. Run the application’s existing suite and each task’s acceptance checks after integration. Verify the FAQ text and keyboard behavior, then export CSV values containing commas, quotes, and line breaks and check their order and contents. Before using this with real user-controlled data in spreadsheets, assess formula-injection handling separately. Test the search shortcut with focus outside a field and inside an input, textarea, and editable region. Check for interference with FAQ controls or established shortcuts, then inspect shared styling at narrow and wide widths. Include integration repairs in the recorded time even when Git applies every patch without a conflict. Patches can combine cleanly while introducing incompatible behavior, so accept the run only after reviewing the combined application. Read the speedup alongside the overhead Record total elapsed time, active human minutes, inference costs, and acceptance for each condition. Divide sequential completion time by parallel completion time for comparable successful runs to calculate speedup, and show unsuccessful runs beside that ratio. For example, hypothetical completion times of thirty minutes sequentially and twenty minutes in parallel give a 1.5× speedup. If the parallel run also requires fifteen additional minutes of your attention, decide whether the ten-minute reduction in elapsed time justifies that involvement. The longest task sets a lower bound on the parallel work stage, with preparation and integration adding time around it. When one task accounts for most of the wait, assigning additional agents to the other tasks will not shorten that task. Add agents only where the work supports them Try two concurrent agents if three sessions leave you answering questions throughout the run. Use the questions to identify missing requirements, then revise the briefs before increasing concurrency again. Keep parallel work for tasks whose boundaries and shared interfaces you can define before launch. When integration repeatedly consumes the time saved during execution, reduce the overlap or complete the shared decision first. Save the task briefs with the combined acceptance checks and use them for the next comparable job. Retain the level of concurrency that gets the application through review within your time and attention budget. Keep timing through integration; that is where you find out whether the extra agents helped. Try it on your next three tasks in Kilo Desktop https://kilo.ai/install desktop . Sources Kilo Desktop sessions and Git worktrees https://kilo.ai/docs/desktop/quickstart Related reading: Kilo Agent Manager and isolated parallel sessions https://kilo.ai/docs/automate/agent-manager