Multi Agent AI Assistant for Software Development Automation for Robosoft
Challenges
High LLM costs and data privacy risks.
Manual effort across the software development lifecycle.
Disconnected agents and tools requiring coordinated orchestration.
Outcome
75–80% reduction in manual effort.
70–75% task execution accuracy.
~3x lower LLM costs and greater data control.
Solution
Multi Agent AI Assistant
Challenges
Solution
Technology Stack
Outcomes
Robosoft Technologies is one of the top digital transformation companies, delivering solutions across multiple industries. It did not need another AI chatbot. They wanted AI that could actually perform software development tasks. Their goal was to automate a large part of the development workflow. From creating user stories and Jira tickets, generating code, working with GitLab and building unit tests. Tools such as ChatGPT and Claude could already perform parts of this work. But using premium LLMs for every action introduced two major concerns like cost and data privacy. Cloudaeon worked with Robosoft to build a multi-agent AI assistant using free and low cost LLMs. The solution brought five specialised agents into one connected workflow, with each agent responsible for a specific stage of software delivery. The result was an AI-driven development workflow that reduced manual effort, kept organisational data within the client's environment and provided a low cost alternative to relying entirely on premium AI models.
Challenges
High Cost of Premium LLMs: The required tasks could be performed using commercial AI platforms. The problem was the cost of repeatedly using premium models across development workflows. The client needed a setup where smaller and routine tasks could be handled without using an expensive model every time.
Data Privacy: The workflow involved organisational data, code, project information and development tasks. The client did not want this information unnecessarily shared with external AI providers. The solution therefore had to provide greater control over where the data was processed.
Too Much Manual Work Across the Development Lifecycle: A normal development workflow involved several separate steps. Teams had to interpret an initial requirement, create user stories, create Jira tickets, write code, push files and branches to GitLab, and then prepare unit tests. Each step involved manual effort and switching between tools
.
Multiple Agents Had to Work as One System: Automating one task was not enough. A user could start by asking for Jira stories and then continue to code generation and GitLab actions. The system had to understand the sequence, remember previous actions, select the right agent and decide which tool should run next. It also needed checkpoints where users could review an output before allowing the workflow to continue.
Root Cause Analysis
Cloudaeon did not start by simply replacing manual tasks with AI agents. The team first looked at why the existing approach was difficult to scale. The problem was not that tools such as Claude or ChatGPT lacked capability. The real issues were the economics of using premium models for every action and the need to protect organisational data.
Solution
Cloudaeon built a multi agent AI assistant consisting of five specialised agents:
User Stories Agent: Converts an initial requirement or description into a first draft of structured user stories.
Jira Agent: Creates and manages Jira tickets, including ticket creation, deletion, updates and comments.
Code Generation Agent: Generates code based on natural language instructions.
GitLab Agent: Performs actions such as creating branches, creating files, pushing development artefacts and handling repository operations.
Unit Test Agent: Generates unit test cases, checks code level and function-level errors, and validates different execution scenarios.
Together, the five agents automated a large part of the path from an initial requirement to development and testing.
How We Delivered
Cloudaeon built the solution agent by agent rather than trying to create the entire workflow at once.
Building Specialised Agent Workflows: Each agent was developed around the actions it needed to perform. For systems such as GitLab, Cloudaeon created an MCP server. The Model Context Protocol layer exposed the APIs and functions required by the agent. Individual actions were represented as tools or nodes. For example, creating a branch, creating a file, or performing another GitLab operation. When a user submitted a request, the LLM interpreted the request and determined which node or tool had to be executed. The corresponding function then called the MCP layer and completed the action.
Orchestrating the Five Agents: LangGraph was used as the main orchestration layer. Instead of treating every request as an isolated prompt, LangGraph allowed the system to manage the workflow between agents and tools. The assistant could first identify which agent was required. It could then determine which tool inside that agent needed to run.
React and Planner-Executor Pattern: Cloudaeon also introduced a React-style pattern, combining reasoning and action. The model first determined what needed to happen. It selected the appropriate agent and tool, performed the action, observed the result and then decided what should happen next. A planner-executor approach was also used, where the planner created the broader execution plan, while individual actions were carried out sequentially. This was important for workflows involving several connected development tasks.
Human Approval Between Critical Steps: The system did not blindly continue through every action. Human checkpoints were introduced between stages. For example, after generating Jira stories, the assistant could present them to the user and ask whether they should be changed or whether the workflow should continue. This kept the user in control while still automating the majority of the execution.
Session Memory: Session memory was added so the assistant could retain the context of previous interactions and completed actions. If a user created a branch and later asked the system to add a file to that branch, the assistant could understand the relationship between both requests.
Real-Time Communication and Streaming: WebSockets were used to support continuous communication between the user and the backend. Streaming was also introduced so users could track activity while a task was being processed rather than waiting for the entire workflow to finish before receiving a response.
VS Code Extension: The solution was not limited to a web interface. Cloudaeon also developed a VS Code extension so developers could use the multi-agent assistant directly from their development environment. Instead of leaving VS Code, opening a separate website, and reconnecting their development tools, users could interact with the assistant from the IDE itself.
Technology Stack
LangGraph
LangChain
Model Context Protocol (MCP)
ReAct prompting pattern
WebSockets
AWS
GitLab
Jira
VS Code Extension
Outcome
75 to 80% reduction in manual effort: Human involvement remained important for reviewing outputs and deciding what was correct.
70 to 75% execution accuracy: In executing the requested tasks across the workflow.
Approximately 3x lower LLM cost: By using free and low cost LLMs, the architecture created a significant cost advantage.
Greater control over organisational data: The approach allowed the client to keep its data within its own environment instead of depending entirely on external commercial AI platforms.
Conclusion
Cloudaeon helped the client move from isolated AI assistance to a multi-agent system capable of taking real actions across the software development lifecycle. If your teams are still moving manually between development tools for repeatable tasks, Cloudaeon can help identify where agentic automation can remove that effort while keeping humans in control of critical decisions. Talk to an expert now.