Introducing Qodo Gen 1.0: Agentic flows for the enterprise

AI coding started with a simple premise: you type a request, and the tool provides some code. 

But real-world development isn’t so linear, especially if you’re working with large-scale, enterprise code. In order to fix a single bug, you may need to check logs and recent code changes, consult documentation, identify dependencies, run debugging tools and test a fix. No matter how good the AI code suggestion, there’s still a lot to do outside the IDE. Today’s AI needs to move dynamically, gather context, handle tasks autonomously, and call to any resource at your disposal. 

It needs to be agentic.

With Qodo Gen 1.0, we bring agentic workflows and tools to our IDE plugins for Jetbrains and VS Code powered by autonomous agents that handle coding tasks end-to-end, dynamically gathering context and executing multi-step problem-solving.

Introducing Agent Mode

Qodo Gen’s new Agent Mode brings agentic coding workflows through AI chat in the IDE, enabling more dynamic, flexible interactions with the AI. Instead of simply executing predefined commands, the agent autonomously breaks down requests into steps, chooses tools, and carries out the request end-to-end. 

Agent vs. Standard Mode

Standard Mode: Command-Response 

In our original mode—now called Standard Mode—Qodo Gen follows a direct command-response approach. When given a prompt, it executes the request precisely without tool selection, and generates an answer. It’s ideal for straightforward queries where immediate execution is required, such as retrieving specific information or generating predefined code snippets. In Standard Mode, users can add repos, files and folders from their codebase for the AI to use as context.

Agentic Mode: Command-Think

Agentic Mode allows the AI to engage in a more autonomous, thoughtful, multi-step process. It first analyzes the request, identifies the tools it needs, gathers context and determines the best approach to solving the problem. If necessary, it applies multiple tools iteratively, refining the response based on gathered context. Agent mode is particularly useful for complex tasks requiring reasoning, multiple data sources, or problem-solving beyond simple command execution.

Here’s some examples of what you can use Agent Mode for:

1. Generate full stack code: Generate a complete REST API using Flask, including routes, models, and database setup.
2. Fix Bugs: Help identify and resolve a memory leak in a Java application by analyzing heap dumps and suggesting optimizations.
3. Implement a Task from Text or a Ticket: Translate a user story into a working feature in a React application, complete with state management and API integration.
4. Build UI Components: Build reusable React components with Tailwind CSS for a responsive web application

Building an infrastructure for agentic flows

Agentic workflows allow AI to be more dynamic and make decisions, rather than following rigid, pre-defined logic. For this level of autonomy we needed an infrastructure that can manage state, handle multi-step processes, and ensure reliable execution. We took a graph-based approach using LangGraph to orchestrate AI interactions and multi-step problem solving. This also allows us flexibility to evolve workflows over time and extensibility to add new tools and capabilities without disrupting the core system. 

Extensible agent and tooling support with Model Context Protocol

A key feature of our agentic workflows is the ability to dynamically discover and select tools based on real-time task requirements. Qodo Gen 1.0 allows you to integrate external tools and services into agentic flows. This extensible tooling is powered by Anthropic’s Model Context Protocol (MCP), enabling seamless interoperability between the AI model and enterprise tools like Jira, Git, APIs, databases and more.

For example, if a Jira MCP is set up, you could ask Qodo Gen to “Find me a Jira ticket about creating an authentication protocol” in the chat and get relevant information from your Jira project.

These tools help Qodo Gen learn more about your project files, search the web, and connect with various integrations. The tools themselves are the “how,” not the “what”—they provide the means for the agent to assist, rather than defining the agent’s function. Moreover, the architecture supports tool chaining, where the AI can autonomously invoke multiple tools in sequence, such as retrieving issue details from Jira, fetching related Git commits, and triggering CI/CD pipelines—all within a single session.

Users can easily add pre-configured or custom MCP tools to Qodo Gen with the required API key, arguments, environment variables and other credentials. 

Agentic test generation 

Test generation has always been at the core of Qodo Gen, driving our mission to help developers push high quality code. Users are familiar with our test generation tools—code behavior analysis, test behavior generation and test suite expansion—which open in a panel within the IDE.

In Qodo Gen 1.0, testing tools are now enabled within the AI chat (in Standard Mode) to give you a semi-agentic flow for test generation. With the same /test command users are used to, Qodo Gen will guide you step-by-step through generating a complete test suite, from adding example tests, mocks to generating edge case behaviors. Tests are created directly inside the editor, giving users full control over everything in the file, from imports to helper functions. The workflow is designed to be flexible, both in the UI and backend, allowing it to evolve as the agent becomes smarter.

Qodo Gen 1.0: powered by Qodo’s code integrity platform 

Qodo Gen is built on our enterprise-ready code integrity platform, ensuring reliable and intelligent AI assistance for developers. From Agent Mode to test generation, this platform powers Qodo Gen with tools for prompt intent understanding, advanced context retrieval, and deep code awareness.

As the first and only MCP-enabled AI coding agent for JetBrains, Qodo Gen seamlessly integrates with enterprise workflows. Its agentic chat enables flexible, intelligent interactions designed for large-scale coding challenges.

To achieve deep context awareness of enterprise codebases, we use:

• Continuous indexing pipelines to keep codebase analysis up to date.
• Advanced Retrieval Augmented Generation (RAG) techniques, including intelligent chunking, retrieval, and ranking mechanisms.
• A state-of-the-art code embedding model that enhances code search, retrieval, and natural language-to-code understanding.

These capabilities allow Qodo Gen to deliver precise, context-aware code, streamlining development, testing, and code review processes.

Conclusion

By moving beyond the limitations of simple command-response interactions to true agentic workflows, we’re enabling AI to become a genuine collaborative partner in tackling the most complex coding challenges.

With Agent Mode, developers can now focus on the “what” while Qodo Gen handles the “how,” autonomously orchestrating multi-step problem-solving processes that were previously beyond the reach of AI tools. Whether you’re generating comprehensive test suites, fixing complex bugs across multiple files, or implementing features from user stories, Qodo Gen 1.0 provides the intelligence and context awareness to deliver meaningful results.