GitHub stars License Open Core

VOLY is an open-core platform for managing the AI agents that take part in building software. It brings together agent execution and coordination, model and provider access, task management, project memory, execution control, result verification and cost tracking in one environment.

VOLY helps move from scattered use of AI tools to a managed development process, where a human sets the goal and the acceptance criteria while agents carry out individual steps under the control of a shared system.

1. Why the project exists

Modern AI coding agents can analyze code, create and edit files, run commands, fix bugs and carry out individual development tasks. But once several tools and agents are in play, you need to manage the whole process, not just code generation:

VOLY provides the infrastructure layer for solving these problems.

2. Core concept

VOLY acts as a control plane for AI-assisted development. The platform isn’t tied to a single model provider or a specific coding agent — it coordinates tasks, executors, tools and checks.

A typical run looks like this:

  1. Set the task. The user describes the desired outcome, constraints and acceptance criteria.
  2. Plan. The task is analyzed and, if needed, broken into sequential or dependent steps.
  3. Orchestrate. VOLY picks suitable executors and models, taking provider availability and constraints into account.
  4. Execute. Agents analyze the project, make changes, run commands and pass results between steps.
  5. Verify. The system collects the results and runs the configured checks.
  6. Record the outcome. Changes, events, spend, check results and feedback are all saved.
  7. Reuse the context. That information can be used in later tasks to keep continuity across the project.

The human keeps control over goals, architectural decisions, access and quality criteria.

flowchart TD
    S(["New task"]) --> C["Gather project context"]
    C --> P["Decompose and plan"]
    P --> G["Does the plan need several roles?"]:::decision
    G -- Yes --> D["Assign roles and executors"]
    G -- No --> D1["Assign a single executor"]
    D --> X["Execute the steps"]
    D1 --> X
    X --> R["Collect changes and results"]
    R --> Q["Checks and evaluation"]
    Q --> OK["Criteria met?"]:::decision
    OK -- Yes --> EV["Build Evidence"]
    OK -- No --> L["Another iteration allowed?"]:::decision
    L -- Yes --> FIX["Adjust the plan / fix issues"]
    FIX --> X
    L -- No --> REVIEW["Hand off for manual review"]
    REVIEW --> EV
    EV --> MEM["Save history and context"]
    MEM --> END(["Task complete"])

    classDef decision fill:#0a0f1a,stroke:#3f63b4,stroke-width:1.5px,stroke-dasharray:6 4,color:#c9d6fb

3. Core capabilities

3.1. Multi-agent orchestration

VOLY lets you run several agents and split work between them by role and purpose.

Typical roles in the development process:

Orchestration covers task decomposition, step management, passing results along, and tracking dependencies. The actual set of roles and the execution scenario depend on the task and the project configuration.

flowchart LR
    U["User"] --> LEAD["Lead Orchestrator"]
    LEAD --> ARCH["Architect"]
    ARCH --> PLAN["Plan and acceptance criteria"]
    PLAN --> DEV["Developer"]
    DEV --> TEST["Tester"]
    TEST --> REV["Reviewer"]
    REV --> DEC["Result accepted?"]:::decision
    DEC -- No --> DEV
    DEC -- Yes --> OUT["Result and Evidence"]

    LEAD -. "Context and state" .-> MEM["Project Memory"]
    MEM -. "Context" .-> ARCH
    MEM -. "Context" .-> DEV
    MEM -. "Context" .-> TEST
    MEM -. "Context" .-> REV

    OUT --> U

    classDef decision fill:#0a0f1a,stroke:#3f63b4,stroke-width:1.5px,stroke-dasharray:6 4,color:#c9d6fb

The diagram shows the logical model of roles. The actual agent lineup, sequence, and whether steps run in parallel depend on the specific workflow.

3.2. Working with models and providers

VOLY supports multiple models and AI providers through a single control layer.

The key jobs of this layer:

This keeps the workflow from depending on a single AI model provider and lets you swap executors without restructuring the whole development process.

flowchart TD
    TASK["Execution request"] --> CLASS["Classify the task's type and requirements"]
    CLASS --> POLICY["Routing policies<br/>Quality · Cost · Availability"]
    POLICY --> SELECT["Select a model / provider"]
    SELECT --> CALL["Call the executor"]
    CALL --> RESULT["Did it succeed?"]:::decision
    RESULT -- Yes --> SAVE["Save the result and spend"]
    RESULT -- No --> HEALTH["Check provider health"]
    HEALTH --> FALLBACK["Is a fallback available?"]:::decision
    FALLBACK -- Yes --> ALT["Pick a backup executor"]
    ALT --> CALL
    FALLBACK -- No --> ERROR["Error / wait / manual decision"]
    SAVE --> DONE(["Return the result"])

    classDef decision fill:#0a0f1a,stroke:#3f63b4,stroke-width:1.5px,stroke-dasharray:6 4,color:#c9d6fb

3.3. Task and execution management

VOLY provides mechanisms for managing the lifecycle of tasks and their steps.

Execution can make use of:

This lets you describe the development process as a managed sequence of actions instead of a pile of unrelated AI requests.

3.4. Project memory and context

Working on a real software product takes more than handing an agent the text of the current task — it also needs project context and the history of earlier decisions.

VOLY builds out a memory layer for saving and reusing information about the work:

Memory cuts down on repeating analysis that’s already been done and keeps continuity across tasks and runs.

3.5. Quality checks and evidence

VOLY records evidence of how a task was carried out — from the project’s changes to the results of checks.

Depending on the scenario, this can include:

That builds a history that shows not just what the agent reported, but what actually happened and what came out of it.

Checks can combine deterministic rules with additional evaluation mechanisms. For decisions that matter, AI evaluation results must not replace independent tests, security checks and human sign-off.

flowchart TB
    RUN["Task run"] --> EVENTS["Execution events"]
    RUN --> DIFF["Project changes"]
    RUN --> CHECKS["Tests and checks"]
    RUN --> COST["Cost and usage"]

    EVENTS --> EV["Evidence Record"]
    DIFF --> EV
    CHECKS --> EV
    COST --> EV

    EV --> HIST["Project history"]
    EV --> FEEDBACK["Human feedback"]
    HIST --> CONTEXT["Update context and memory"]
    FEEDBACK --> CAL["Calibrate evaluation mechanisms"]
    CONTEXT --> NEXT["Next tasks"]
    CAL --> NEXT
    NEXT --> RUN2["New run"]

3.6. Cost control

Running several models and agents calls for transparent cost tracking.

VOLY builds out FinOps tooling for AI development:

The goal is to make agentic development’s cost observable and manageable, not just its quality.

3.7. Integrations and extensibility

VOLY is designed as an extensible platform that can plug into existing development processes.

The project ships API and SDK approaches, integration mechanisms, and support for talking to external tools, including over MCP. That means new tools and scenarios can be added without tying the whole system to one fixed set of executors.

4. Architecture model

At a conceptual level, VOLY is made up of several interconnected layers:

LayerPurpose
Intent LayerTakes in the task, goals, constraints and acceptance criteria
Orchestration EngineDecomposition, planning, routing and agent coordination
Agent ExecutionRuns tasks via agents, models and tools
Workflow & StateManages steps, dependencies, state and lifecycle
Governance & VerificationPolicies, constraints, checks and recording results
Memory & Project ContextPersists context, history and project knowledge
Telemetry & FinOpsObservability, events, performance and cost
Integration LayerAPI, SDK and connections to external tools

Together these layers form the overall control loop for agentic development: from setting the task to a verifiable result.

VOLY Control Plane

System layers — from intent to a verifiable result

Intent Layer
Takes in the task, goals, constraints and acceptance criteria
↓
Orchestration Engine
Decomposition, planning, routing and agent coordination
Agent Execution
Runs tasks via agents, models and tools
Workflow & State
Steps, dependencies, state, lifecycle
↓
Governance & Verification
Policies, constraints, checks and recording results
↓
Memory & Project Context
Context, history, decisions
Telemetry & FinOps
Observability, cost
Integration Layer
API · SDK · MCP

5. Local and cloud scenarios

VOLY follows an open-core model and targets two usage scenarios.

VOLY Local

The local scenario is for developers and teams who want to run and control agentic processes inside their own environment.

It brings agent management close to the existing repository, tooling and development infrastructure.

VOLY Cloud

The cloud scenario is for centralized, team-wide agentic work and shared data across participants.

Planned directions for the cloud environment include shared run history, centralized management, cost tracking, team-wide context and running tasks in cloud infrastructure.

flowchart TB
    subgraph LOCAL["VOLY Local"]
        LC["Local interface / CLI"]
        LO["Local orchestration"]
        LE["Local agents and tools"]
        LP["Local projects and environment"]
        LC --> LO
        LO --> LE
        LE <--> LP
    end

    subgraph CLOUD["VOLY Cloud"]
        CC["Cloud interface"]
        CO["Cloud control plane"]
        CH["Team history and context"]
        CF["Management and analytics"]
        CC --> CO
        CO <--> CH
        CO <--> CF
    end

    LOCAL <-->|"Sync and connection<br/>where supported"| CLOUD

The diagram reflects the target Local + Cloud product model, not a claim that every sync path shown is already built.

6. Who VOLY is for

Individual developers — to manage several AI tools, keep project context, and control the cost of agentic development.

Small product teams — to split tasks across agents, standardize development processes, and get a shared history of what ran.

Technical leads and CTOs — to manage quality, constraints, cost and the repeatability of AI-assisted development.

Companies adopting AI agents — to build controlled infrastructure where agents can do engineering work within set policies and processes.

7. Project principles

8. Where it’s heading

VOLY’s long-term goal is to become the infrastructure platform for Agentic Engineering: software development where AI agents handle a significant share of the engineering work, while a human manages intent, architecture, policy and the quality of the result.

Platform development is focused on a few directions:

flowchart LR
    INTENT["Human intent"] --> PLAN["Planning"]
    PLAN --> EXEC["Agent work"]
    EXEC --> VERIFY["Independent verification"]
    VERIFY -->|Accepted| DELIVER["Verifiable result"]
    VERIFY -->|Rejected| REPAIR["Fix"]
    REPAIR --> EXEC
    DELIVER --> LEARN["History and feedback"]
    LEARN -.-> PLAN
    HUMAN["Human control<br/>Architecture · Policy · Acceptance"] -.-> PLAN
    HUMAN -.-> VERIFY

This diagram captures VOLY’s core principle: agents do the engineering work, while the platform provides coordination, observability and control; the human keeps responsibility for goals, architecture and accepting the result.

9. In short

VOLY is an open-core control plane for AI coding agents and Agentic Engineering. The platform brings together agent orchestration, model routing, task management, project memory, result verification, integrations and cost control. VOLY helps developers and teams build managed, observable and extensible development processes powered by AI agents.

VOLY — from individual AI agents to a managed engineering system.


Repository and source code: github.com/voly-codes/voly