Today, Qodo is excited to release our new Agentic Toolbox, a packaged set of tools and skills that brings Qodo’s Context Engine, independent review, and governance capabilities directly into coding agent workflows.

The Agentic Toolbox equips coding agents with ready-made tools and skills for understanding the systems they change and bringing quality into every stage of their work. With the toolbox, agents can:

• Investigate and understand cross-repository dependencies, pull request history, specifications, and live Git state before changing code
• Invoke an independent Qodo review on committed and uncommitted local changes before opening a pull request
• Load your relevant global, workspace, and repository rules from Qodo before implementation begins
• Pull structured PR review issues directly into the coding session for resolution
• Create, update, activate, and scope rules across repositories

For development teams, this means cleaner pull requests, shorter review cycles, fewer issues pushed downstream, and more time for the decisions that require human judgment.

Try it now

macOS/ Linux (including Git Bash and WSL): curl -fsSL https://get.qodo.ai | sh

Windows Powershell: powershell -ExecutionPolicy Bypass -Command "irm https://get.qodo.ai/install.ps1 | iex"

Why we built the agentic toolbox

Software development has always been a team sport. Engineers do not make decisions from a task description alone. They draw on architectural history, specifications, cross-repository dependencies, previous pull requests, and organizational conventions. But as coding agents take on more engineering decisions, that shared knowledge does not automatically follow them, leaving agents to make consequential changes without seeing which repositories could break, which decisions past reviews already settled, or which standards the code must meet.

Qodo’s Agentic Toolbox brings that knowledge directly into the coding session. Once installed through your coding agent or CLI, it gives the agent ready-made skills for invoking Qodo as it works. The agent can bring cross-repository dependencies, pull request history, specifications, and team rules into its plan before writing code, then run an independent Qodo review on local changes before a pull request exists.

The coding agent builds; Qodo is its dedicated quality counterpart. Humans stay in control of the standards, risk boundaries, and escalation policies that govern the whole system.

How the Agentic Toolbox Works

The Agentic Toolbox packages Qodo capabilities into focused skills that coding agents can invoke from natural-language requests. When the task requires deeper context, applicable standards, independent review, or issue resolution, the agent calls the relevant Qodo skill. Qodo performs the work and returns structured context or findings directly to the coding session.

Coding agents consume Qodo’s intelligence while planning, drafting, and checking code:

• qodo-codebase-wisdom: Taps Qodo’s relationship graph, pull request history, and live Git state to answer structural questions, trace regressions, and map cross-repository impacts.
• qodo-review: Runs Qodo’s PR review engine on local committed and uncommitted changes before a PR exists, sharpening findings with live session context.
• get-qodo-rules: Loads global, workspace, and repository coding standards into the agent session before code is written, ensuring organizational rules are reflected in the first draft.
• qodo-review-resolver: Fetches PR review findings from Qodo for the agent to investigate and resolve.

Qodo also gives authorized administrators a direct path for managing Qodo itself. Through the qodo-manage-standards skill, they can create, update, activate, deactivate, re-scope, and bulk-edit organizational rules from inside the agent session.

Bring Quality into the Agentic SDLC

Consider a developer asking a coding agent to change retry behavior in a payments service.

Update the payments service so transient failures retry up to three times with exponential backoff. Permanent failures should not retry. Keep the change scoped and get it ready for a pull request.

Understand the wider system

Rather than immediately modifying the code, the coding agent invokes Qodo to understand the system around the task. It examines connected repositories, cross-repository relationships, pull request history, specifications, and live Git state.

The agent discovers which services depend on the affected interface and surfaces a previous pull request that explains why certain payment failures must never be retried. That context becomes part of its implementation plan without the developer having to locate or supply it.

Retrieve the standards that apply

The developer can review the proposed approach and respond naturally:

Looks right. Build it according to our usual payment patterns and call out any requirement you cannot satisfy.

As it plans the change, the agent retrieves the applicable global, workspace, and repository standards from Qodo. It learns that payment operations require an idempotency key, outbound requests must include an explicit timeout, and sensitive request data cannot be written to logs.

Implement and independently review the change

The coding agent implements the change and runs the relevant tests. Before preparing the pull request, it invokes Qodo’s independent review on the committed and uncommitted local changes.

Qodo identifies an unbounded retry loop and a missing idempotency key, then returns both issues directly to the coding session. The developer can define how much the agent should handle autonomously:

Fix anything you can resolve safely. Leave decisions that could affect production behavior for me to review.

The coding agent updates the implementation, explains what it changed, and invokes Qodo again to validate the fix.

Resolve issues after the pull request opens

If the pull request review surfaces another issue, the developer can continue the same workflow without copying comments into the coding session:

Can you take care of the remaining comments on PR #1284? Flag anything that needs a product or architecture decision.

The coding agent retrieves the structured issues directly from Qodo’s review system, investigates them in the context of the code and original task, and resolves what it can safely. Anything that requires human judgment is surfaced with the relevant context.

By the time the pull request reaches a person, the change has been informed by the wider system, written against the organization’s standards, and independently reviewed. Human attention can focus on unresolved risks and engineering decisions instead of basic issue discovery.

Use the Agentic Toolbox across development workflows

The same capabilities can support a range of engineering tasks.

• Build a feature: Investigate the surrounding system, retrieve applicable standards, implement the feature, review local changes, and resolve issues before opening the pull request.
• Debug an issue: Trace the behavior across repositories and development history, identify the likely cause, implement the fix, and review the change against the wider system.
• Refactor safely: Map the blast radius before changing an interface, apply current standards during implementation, and review the local diff for regressions.
• Upgrade a dependency: Find usages across connected repositories, understand affected contracts, make the migration, and identify compatibility issues before the change reaches review.
• Fix a security issue: Trace the relevant code path, retrieve security standards, validate the proposed fix, and escalate any remaining high-risk decisions to a person.
• Onboard to an unfamiliar system: Ask Qodo how a service works, explore its dependencies and history, learn the applicable engineering rules, and review a first change with greater context.

Getting started with the Agentic Toolbox

The Agentic Toolbox is available now via Qodo’s plugin’s for Claude Code, Codex, and Kiro. The toolbox can also connect with any MCP-compatible client or coding agent.

To Install the toolbox via CLI use the command

macOS, Linux, Git Bash, or WSL

curl -fsSL https://get.qodo.ai | sh

Windows PowerShell

powershell -ExecutionPolicy Bypass -Command "irm https://get.qodo.ai/install.ps1 | iex"

The installer detects supported coding agent environments and configures the available Qodo tools.

Sign in or create a Qodo account when prompted. You can also authenticate directly from the command line:

qodo login

Then return to your coding agent and work as usual. Ask it to investigate a system, check the standards that apply, review local changes, or resolve issues from an open pull request. The agent will invoke the relevant Qodo skills from inside the session.

For setup instructions, supported interfaces, and example workflows, visit the Agentic Toolbox documentation.