Phloem

Inspiration Phloem started from a problem I had myself. I was developing several software projects at the same time, often working locally across different repositories, agents, tools, deployment environments, and long task lists. The difficult part was not writing code. It was keeping track of context: what an agent was doing, what had already been tested, what was blocked, how much AI usage a feature was consuming, and what still needed review before something could ship. I wanted something closer to a real software team, but made of AI agents that I could coordinate from one place. That became Phloem. What it does Phloem is an agentic software engineering control layer for repositories, budgets, and delivery. Instead of using one AI coding agent in isolation, Phloem organizes agents into a team with different responsibilities. Tasks move through a Kanban-style workflow, and agents can act as engineers, testers, reviewers, product owners, or other specialized roles. A feature can be broken into tasks, assigned to agents, implemented, tested, reviewed, blocked when something is wrong, and eventually approved for delivery. Phloem also makes the process visible. You can see tasks, agent activity, repository state, CI/CD status, blockers, acceptance criteria, and AI spending instead of having agent work disappear inside individual prompts. The goal is to make agentic development manageable enough to run several software projects without constantly switching between tools and rebuilding context. How we built it I first developed the workflow while working locally on Phloem and my other projects. That local development process became the blueprint for the product itself. Phloem combines a web application built with Lovable with GitHub-based development workflows and Gemini-powered agents. The application provides the control plane, while agents perform software engineering tasks around the repository. The system includes role-based agents, task orchestration, Kanban workflows, acceptance criteria, testing and review stages, blocking and unblocking logic, repository visibility, budget tracking, and deployment status. Rather than asking one model to do everything, the workflow separates responsibilities. An engineering agent can implement a task, a tester can inspect or generate tests, and a reviewer or product-owner agent can verify the result against the original requirements. We also designed the system around constrained AI usage. Tasks can have budgets, agent activity can be tracked, and the workflow is structured so expensive reasoning is used where it adds value instead of repeatedly sending the entire project context to a model. Challenges we ran into One of the biggest challenges was turning AI coding from a conversation into a reliable workflow. Agents can generate code quickly, but real software delivery requires much more: understanding repository state, maintaining context across tasks, handling failures, running tests, reviewing changes, tracking dependencies, and knowing when something is actually finished. Another challenge was making autonomous work understandable. If several agents are operating on a project, the developer needs to know why a task was changed, why something became blocked, what was tested, and what an agent recommends doing next. Budget and context management were also important. Sending increasingly large repositories and conversations to an LLM is expensive and inefficient, so Phloem needed a more selective approach to context and execution. Finally, building the product while also using it as part of my own development process meant the system was constantly being tested against real problems rather than only demo scenarios. Accomplishments that we're proud of The biggest accomplishment is that Phloem evolved from my own local development process into a working model for coordinating an AI software team. Instead of another chat interface for coding, the project treats software development as a lifecycle: plan, implement, test, review, unblock, approve, and deploy. I'm particularly proud of making the agent workflow visible and controllable. Developers can understand what agents are doing instead of treating autonomous coding as a black box. Phloem also brings together repository work, agent roles, task management, budgets, testing, review, and delivery into one product experience. Most importantly, it addresses the original reason I built it: allowing me to work across multiple projects without losing development context every time I switch between them. What we learned The biggest lesson was that better models alone do not solve software engineering coordination. The structure around the model matters just as much. Agents perform better when they have a clear role, a limited task, explicit acceptance criteria, access to the right repository context, and another agent or workflow stage checking their output. I also learned that visibility is essential for agentic systems. Autonomous execution becomes much more useful when developers can inspect decisions, costs, blockers, tests, and progress. Another lesson was that context should be treated as a resource. More context is not always better. Selecting the right context for each task can reduce token usage while also making agent behavior more focused. Building Phloem from a workflow I was already using locally also helped keep the product grounded in an actual engineering problem instead of designing agent features only because they were technically possible. What's next for Phloem The next step is turning Phloem into a complete operating environment for agentic software teams. I want agents to be able to take a feature from specification all the way to a reviewed and deployable implementation, while keeping the developer in control of budget, architecture, security, and approvals. Future work includes deeper repository intelligence, stronger automated testing and review, smarter task and budget allocation, better token and context optimization, CI/CD execution, deployment controls, repository migration recommendations, security analysis, and more autonomous creation of engineering tasks. Phloem will also continue evolving as a system I use myself to build multiple products. The long-term goal is simple: instead of managing individual AI prompts, developers should be able to manage an entire AI software team.

Built With

• gemini
• javascript
• lovable
• openai
• rust