Sage

Most AI coding tools stop at the editor. Sage starts there and goes all the way to a merged pull request — with every decision traced, every quality gate enforced, and nothing hidden in a black box.

Origin

Years spent as a system architect leave a particular mark. You see, up close, the gap between what teams intend and what they deliver. The context switching. The dropped details. The pull requests that carry no trace of the thinking behind them.

Sage was built to close that gap — not by replacing engineers, but by giving AI agents the same structured discipline a senior engineer brings to delivery work.

The Empty Quadrant

The current tool landscape splits neatly along two axes: low-code automation for business users on one side, AI coding frameworks for developers on the other. CI/CD lives in its own corner, disconnected from both.

Nobody has connected them — with delivery semantics, composable agents, and quality gates as first-class citizens.

That is the space Sage occupies.

How It Works

A Run in Sage takes an issue reference and walks it through a configurable pipeline:

1. Analysis — read the issue, understand intent, extract constraints
2. Planning — architectural decisions, task decomposition, approach validation
3. Implementation — AI runtime (Cursor CLI, OpenAI, or mock) executes the code changes
4. Quality gates — lint, build, and test run automatically, with fix loops on failure
5. Verification — local artifacts produced, CI handoff documented
6. Pull Request — opened with a full trace of decisions and outcomes

Every step is observable. Every artifact is persisted. The Run is a first-class record, not a log.

Architecture

Blackboard Model

At the core of every Run is a Blackboard — a shared, typed space where specialized agents contribute facts that other agents can read and act on. The analyst writes its findings; the architect reads them and writes decisions; the quality guard reads those and enforces constraints.

Each Run has its own isolated blackboard. Agents are composable, not hardcoded.

Ports & Adapters

Sage is built on Clean Architecture. Every external dependency — work item providers, source control, AI runtimes, CI systems — is behind a port. Swap providers without touching the core.

• Work items: Gitea, GitHub, GitLab, Jira
• AI runtime: Cursor CLI, OpenAI, or mock — configurable per run
• SCM: any git host

Configuration Over Code

Workflows are defined as JSON DAGs, not hardcoded pipelines. Configuration merges in layers:

global defaults  <  project settings  <  run override

Every config version is stored, diffable, and rollbackable. Tech leads stay in control of what the agents are allowed to do.

Who It’s For

Tech leads and staff engineers who want to automate repetitive delivery work without sacrificing the quality standards they’ve spent years building.

Platform engineers building internal AI delivery tooling — self-hosted, provider-agnostic, auditable.

Multi-repo startups who need consistency in planning and implementation across services.

Teams with compliance requirements — every decision is an artifact, every step is traced, nothing is implicit.

Stack

Built in TypeScript 5, structured as an npm monorepo. API layer on NestJS, worker runtime in plain Node.js, UI in React 19. PostgreSQL for persistence. Deployed via Docker Compose.

Status

The core pipeline is functional. Agent composability, the Agent Factory UI, and extended multi-provider support are actively in progress.