What we are missing
Every developer now has a chat companion. Every IDE, every little harness has a chat window where you can use it to vibe your million dollar idea at night to save the world, and your jira ticket in the morning to feed your cat. And that's great, the chat companion is basically your partner with many different hats, sometimes they are the pair programmers, sometimes they're the analyzers, sometimes they're your junior programmer, and sometimes they're your mentor. This is truly great for your vibe-coding sessions.
But let's talk about your team environment with everyone in it, collectively. This is the "software factory" that we're talking about now, the one with all the processes, workflows and rules.
Do you think individual vibe coding - with a separate chat companion per developer - is an effective way to run a software team?
Workflow execution problem
Work in team environments almost always starts with a ticket and ends with a PR merged (and tested, hopefully). Let's say that you're past the chat companion phase and have moved into the agentic development world. Welcome. Now you start thinking about automations, workflows. There are harnesses out there that implement certain workflows and automate the development process. One thing we see missing in these harnesses and automations is that they are mostly non-deterministic. Try it, one day everything will run smoothly, the next day with a larger task an agent will decide that he has done everything necessary to complete the ticket and it doesn't need to do a QA step, skip to done!
Coro workflows you can trust on
With Coro, deterministic workflow execution is guaranteed through code. The workflows are defined as markdown files and you're able to define any workflow and add it to Coro's workflow repository, but the steps of these workflows (defined in the front-matter of each workflow .md file) ensure that the workflow is executed by the Coro engine deterministically. There are also multiple lanes (multiple workflows). A quick 1 liner bug fix doesn't really require so many workflow steps as larger "let's implement x feature", so the planner agent is able to triage issues and switch workflows when it deems necessary. This gives Coro the flexibility to adap to any kind of task - from 1 liner fixes to workflows that run for weeks.
Coro ships with a good baseline collection of workflows and agents that are able to handle many different kind of tasks, but you are able to add your own or tweak the ones in there according to your needs. Ability to switch workflows is something you can define and configure within the intelligence files as well.
More information about workflows in Coro can be found here.
Moreover, having the workflows executed by code gives us the ability to park any job to the side, waiting for input, wasting 0 LLM resources. Cases where this is useful are:
PR review stage, waiting for comments and approvals. Coro agents park the job once they submit a PR, listening and reacting to PR comments as they come in. PR comments are great way for developers to interact, give feedback and steer Coro in the way they want. While waiting, job is parked.
Escalation: Coro can escalate and park the job waiting for developer input when an unclear situation arises. No automatic assumptions are made.
Pause: You can always pause a job manually. This causes the job to be parked aside until the developer resumes it back.
Interactive mode: During execution when a phase is complete, the runner automatically advances to the next workflow phase. Sometimes you may not want that, instead you may want to review the artifacts produced by Coro agents and give feedback before moving into next phase. Coro gives the developers ability to run any job in interactive mode where the job is parked after each phase completion.
Rate Limits: Coro is intelligent enough to wait and resume when an LLM rate limit is encountered. When Claude tells Coro to wait 4 hours, the job is parked and resumed after 4 hours. Rate limit handling is what allows Coro to run workflows for days and weeks.
In all of these cases and more when a job is parked, a full job state is persisted to the storage which allows Coro to resume jobs throughout restarts and all the meanwhile wasting 0 LLM resources.
COLD START PROBLEM
Knowledge sharing is an important aspect of team development. Agile methodologies provide ceremonies to facilitate human knowledge sharing and developers are encouraged to share the knowledge they have surfaced while working on a task, sometimes specific to a repository or team-wide.
What happens to this knowledge when agents are writing the code?
Vibe coding completely removes this ceremony and provides no means of long term knowledge sharing between agents. There are many components you can install in order to provide RAG stores, but there are many questions around how these memory records are created, categorised and stored.
How Coro solves this problem
Coro agents are instructed to collect "insights" while they are working. Insights are quirks and knowledge they discover about the code, the tools or even the processes during their execution. These insights are recorded throughout the job's lifecycle and persisted together with the job. There is an evaluator agent who runs at the end of each job who evaluates these insights, categorises them (are they specific to this repository, or are they team-wide knowledge?). It also checks the existing knowledge base and if an insight is worth storing, it creates a pull request. For repository specific knowledge, Coro creates a PR to the repository (.coro folder in each repository contains repo-wide knowledge) and if it's a team-wide knowledge, it creates a pull request to the team intelligence repository.
Coro does this automatically while it's the humans who review, merge or reject the insights to the knowledge base. Merged knowledge records are shared and utilised by every Coro installation within the team, providing team wide seamless knowledge sharing while developers remaining in control.
What you get
With Coro, you get to:
start a job through a ticket or plain text.
Coro writes the spec, plans the execution and handles the task creation.
Workflow steps of coding, review, qa, evaluation are handled deterministically while the agents are free to roam and explore within their boundaries.
Job moves along the phases while you have the visibility and ability to review and steer on every step.
Pull requests are created and fully managed by Coro, being reactive to steering comments and inputs.
Once merged, tests are evaluated and knowledge persisted, making Coro better itself for the next job.
Let's make it better!
Coro is open source. It's only making it's first steps and it can only get better with us collectively! Download Coro, play with it and contribute in any way you want to make Coro better.
https://github.com/Coro-ai-framework/coro-developer-framework
Top comments (0)