Dromeas

Dromeas is a continuous code review and release intelligence platform for engineering teams that want checks to happen on every change, not just immediately before a merge or release. It reviews pull requests and default-branch commits, then applies the same evidence-based approach to tagged releases so teams can understand what changed and where the risks may be.

The platform is built around a shared Code Map of the codebase. This mapped view helps Dromeas reason about callers, dependencies, blast radius, and release scope, allowing findings to be connected to actual code paths rather than being limited to the files changed in a commit.

Key Features

Continuous Code Review

Review code changes across pull requests and default-branch commits.

Dromeas is designed to analyze:

• Pull requests
• Trunk or default-branch commits
• Ongoing code changes
• Changes introduced outside a traditional PR workflow

This supports teams using trunk-based development or workflows where important changes may land directly on the default branch.

Code Map Reasoning

Analyze changes using a mapped view of the wider codebase.

Dromeas uses a shared Code Map to understand how code is connected beyond the individual file being changed.

This can help identify:

• Caller paths
• Related code
• Dependencies
• Potential blast radius
• Release scope
• Areas affected by a change

The same mapped view is used across review, release checks, documentation, tests, and fixes.

Specialist Review Agents

Review code changes across multiple engineering concerns.

Dromeas brings together specialist agents that focus on different aspects of a code change.

These checks can cover:

• Code quality
• Security
• Compliance
• Unit tests
• Documentation gaps

The outputs from these checks are combined into a single review verdict rather than leaving teams to manually consolidate findings from separate tools.

Evidence-Based Findings

Connect findings to the code paths and evidence behind them.

Dromeas is designed to provide more than a generic warning or issue label.

Findings can include context such as:

• Relevant caller paths
• Supporting evidence
• Potential blockers
• Related changes
• Trends across code changes

This gives engineering teams more context when deciding whether an issue needs immediate attention.

Trunk and Default-Branch Analysis

Continue checking code after it reaches the main development branch.

Dromeas supports analysis of every default-branch commit, not only pull requests before merge.

This can be useful for teams working with:

• Trunk-based development
• Frequent deployments
• Direct commits
• Rapid iteration
• Hotfixes

Continuous analysis helps maintain review coverage even when changes do not follow a traditional long-lived pull request workflow.

Release Scope Analysis

Review releases against the full set of changes included in the release.

Dromeas applies its analysis process to tagged releases and evaluates the broader release scope.

This can help teams understand:

• What changed in the release
• Which code paths are affected
• Potential blockers
• Areas with increased risk
• Trends across included changes

This gives release checks a broader scope than reviewing individual pull requests in isolation.

Release Notes Generation

Draft release notes from the actual release diff.

Dromeas can use the changes included in a release to generate release notes based on the real code differences.

This can help teams reduce the manual work involved in:

• Reviewing merged changes
• Identifying release contents
• Summarizing updates
• Preparing release documentation

The release notes workflow is tied to the actual release scope rather than relying only on manually maintained summaries.

Code Map for Tests and Documentation

Use the same codebase understanding across multiple engineering tasks.

The Code Map is not limited to identifying review issues.

It can also support work involving:

• Unit tests
• Documentation
• Code fixes
• Release analysis
• Dependency reasoning

Using the same mapped understanding across these workflows can help keep analysis connected to the wider codebase.

Multi-Model Council

Use multiple models to evaluate the same finding.

Dromeas supports a council-style approach in which multiple models can judge the same finding.

This can provide an additional layer of evaluation when teams want to compare or validate model-generated conclusions.

The approach is designed to give teams more control over how AI-assisted findings are assessed.

OpenAI-Compatible Model Endpoints

Connect compatible model infrastructure to the review workflow.

Dromeas supports OpenAI-compatible endpoints, including self-hosted options.

This can be useful for teams that want greater control over:

• Model selection
• AI infrastructure
• Where code is processed
• Internal deployment requirements

Self-hosted or compatible endpoints can help organizations align the AI workflow with their existing infrastructure requirements.

MCP Access

Use Dromeas from supported IDEs and AI assistants.

Dromeas provides access through a hosted Model Context Protocol server.

This allows the platform to connect with:

• Compatible IDE environments
• AI coding assistants
• MCP-enabled workflows

Teams can therefore bring Dromeas capabilities closer to the environments where engineering work is already taking place.

Repository Platform Support

Connect the platform to supported source code providers.

Dromeas supports:

• GitHub
• GitLab
• Bitbucket Cloud

This allows teams using different repository platforms to apply the same continuous analysis and release workflow.

Built for Continuous Code Review and Release Checks

Dromeas combines continuous code review, Code Map reasoning, specialist agents, release analysis, evidence-based findings, multi-model evaluation, and MCP access into one engineering workflow.

Key benefits include:

• Review pull requests continuously
• Analyze every default-branch commit
• Understand callers and code dependencies
• Evaluate potential blast radius
• Check code quality and security concerns
• Identify compliance gaps
• Surface missing tests
• Identify documentation gaps
• Connect findings to supporting evidence
• Analyze tagged releases
• Review the full release scope
• Generate release notes from actual diffs
• Use multiple models to evaluate findings
• Connect OpenAI-compatible and self-hosted model endpoints
• Access capabilities through MCP
• Support GitHub, GitLab, and Bitbucket Cloud

Built For

• Software Engineering Teams
• Development Teams
• Platform Engineers
• Engineering Leaders
• DevOps Teams
• Security Teams
• Compliance Teams
• QA Engineers
• Developers Using Trunk-Based Development
• Teams Managing Frequent Releases
• Teams Handling Production Hotfixes
• Organizations Using AI Coding Assistants

Common Use Cases

• Reviewing pull requests before and after merge
• Monitoring commits on the default branch
• Identifying the blast radius of a code change
• Finding security or quality issues
• Checking for missing unit tests
• Identifying documentation gaps
• Investigating callers and affected code paths
• Reviewing the scope of a tagged release
• Generating release notes from real code changes
• Supporting frequent deployment workflows
• Reviewing production hotfixes
• Comparing findings across multiple AI models
• Connecting review workflows to IDEs and AI assistants
• Using self-hosted model infrastructure where required
• Keeping continuous analysis connected to repository activity

Why It Matters

Code review is often concentrated around the pull request. Once code is merged, teams may rely on separate release checklists, manual investigation, testing tools, and documentation processes to understand the wider impact of what changed.

That can create gaps when teams work with trunk-based development, frequent deployments, direct commits, or production hotfixes. A change may look isolated when viewed as a diff but affect callers, dependencies, or release behavior elsewhere in the codebase.

Dromeas takes a broader approach by using a shared Code Map to reason about the codebase and applying that context to pull requests, default-branch commits, and tagged releases. Specialist agents examine different concerns, while the platform connects findings to supporting evidence, caller paths, and broader release scope.

The same approach also extends to tests, documentation, fixes, and release notes, helping teams use one mapped understanding of the codebase across multiple engineering workflows.

Review Every Change and Understand Every Release

Review pull requests and default-branch commits continuously, analyze changes through a shared Code Map, identify caller paths and potential blast radius, check quality, security, compliance, tests, and documentation, evaluate tagged releases against their full scope, generate release notes from actual diffs, validate findings through multiple models, connect compatible or self-hosted AI endpoints, and access the workflow through MCP across supported engineering environments.