Phloem

• 

  landing page

nspiration Phloem started from a very practical problem: managing development across multiple software projects at the same time. Switching constantly between repositories, tasks, tools, models, deployments, bugs, reviews, and project priorities creates a huge amount of context switching. Even with AI coding tools, I still had to repeatedly explain project context, decide what should happen next, review outputs, track costs, and coordinate development manually. I wanted a system that could keep project context, divide work between specialized agents, continue execution across multiple projects, and let me supervise everything from one place. That became Phloem: an AI-native engineering team designed to help developers scale across many projects without having to personally manage every individual development step. What it does Phloem is an AI-native engineering workspace where specialized agents collaborate to plan, build, test, review, and deploy software across multiple projects. A developer connects a repository and defines a feature, issue, or larger goal. Phloem breaks the work into tasks and coordinates agents with different responsibilities, including:

• Planner
• Developer
• Tester
• Reviewer
• Repository auditor
• Security agent
• Deployment agent Each agent can use a different LLM based on the task, work within an assigned budget, and execute work through a Kanban-style workflow. Phloem keeps project context available across the workflow, reducing the need to repeatedly explain architecture, previous decisions, current tasks, and implementation constraints. It also provides visibility into token usage, model costs, task status, CI/CD, code changes, reviews, and deployments. Instead of managing every coding session separately, the team can supervise multiple AI engineering workflows from one workspace. How we built it We built Phloem as a control and orchestration layer for AI-driven software development. The platform combines:
• Multi-agent orchestration
• Persistent project context
• Multiple project workspaces
• LLM routing
• Specialized agent roles
• Task decomposition
• Kanban-based execution
• Per-agent and per-project budgets
• Token and cost monitoring
• GitHub repository workflows
• Automated testing and review
• CI/CD visibility
• Repository auditing
• Deployment workflows
• Team approval checkpoints A key part of the architecture is separating the agent role from the underlying model. A developer agent, for example, does not always need to use the same LLM. Phloem can route different tasks toward different models depending on complexity, context requirements, cost, latency, and remaining budget. We also designed the interface around multi-project development. Instead of opening separate AI conversations and rebuilding context every time, Phloem keeps the execution state, project tasks, agent activity, costs, and code changes organized in one place. Challenges we ran into One of the biggest challenges was managing context. When several projects are being developed simultaneously, each has its own architecture, repository structure, requirements, previous decisions, bugs, and priorities. Sending too much context to every model wastes tokens, while sending too little can produce incorrect implementations. This led us to focus heavily on context selection and token optimization. Another challenge was coordinating agents reliably. A developer agent should not simply implement something and mark the task complete. A tester needs to validate it, a reviewer needs to inspect the implementation, and failed work should return to the appropriate stage. Budget control was another important problem. Different models vary significantly in cost and capability, so using the strongest model for every task would make autonomous development unnecessarily expensive. We therefore designed Phloem around model routing, individual agent budgets, project budgets, and visible spending. Finally, we had to make parallel development understandable. If multiple agents are working across several repositories, the team needs to immediately understand what is running, what failed, what changed, what is waiting for approval, and what should happen next. Accomplishments that we're proud of We are proud that Phloem goes beyond a traditional AI coding assistant. Instead of managing one prompt or one coding session at a time, Phloem is designed around persistent projects and coordinated engineering workflows. Agents have separate responsibilities, tasks, budgets, and review stages. The platform also makes AI development observable. The team can see which agent is working, what task it is executing, which model it uses, how much it costs, what code changed, whether tests passed, and whether the project is ready for deployment. Another important achievement is the multi-model architecture. Phloem is designed so different models can compete for different types of work instead of locking an entire engineering workflow to a single provider. Most importantly, Phloem gives us a way to scale development across multiple projects without multiplying the amount of context switching required to manage them. What we learned The biggest lesson was that scaling AI-assisted development is not mainly a code-generation problem. It is an orchestration and context-management problem. Writing code is only one part of software development. Planning, remembering architectural decisions, selecting relevant context, testing, reviewing, budgeting, prioritizing, deploying, and coordinating work between projects are equally important. We also learned that stronger models do not automatically produce a better development system. Agents need clearly defined responsibilities, permissions, budgets, success criteria, and feedback loops. Context is also a resource. Sending an entire repository into every request is expensive and inefficient. A useful agentic development platform needs to decide not only which model should perform a task, but also which information that model actually needs. Finally, the more development becomes autonomous, the more important visibility becomes. The team should always be able to understand what the system is doing and intervene when necessary. What's next for Phloem The next step is making Phloem capable of managing more development work across more projects while reducing the amount of coordination required from the team. We plan to expand:
• Dynamic model selection based on task complexity, performance, and price
• Intelligent context selection for each agent
• Cross-project context management
• Automatic budget allocation between agents
• More advanced token optimization
• Parallel execution across multiple projects
• Repository-wide architecture audits
• Automatic technical-debt detection
• Migration and modernization proposals
• Security and compliance agents
• Automatic creation of development tasks from repository analysis
• Stronger tester and reviewer feedback loops
• Deployment verification and rollback workflows
• Agent performance scoring
• Model performance comparison
• Cross-project knowledge reuse
• Support for additional model providers and development environments Our long-term vision is for Phloem to become an operating system for AI-native software engineering teams: a place where the team defines goals, specialized agents execute the development workflow, project context stays organized, and every task, model decision, cost, and code change remains visible. The goal is simple: make it possible for a small team to build and maintain many more software projects without scaling context switching and coordination overhead at the same rate.

Built With

• cloud
• gemini
• google
• javascript
• lovable