The open-source accelerator for platform engineering
and Agentic AI at enterprise scale.

Backstage on Azure, six layers of governance, the Horizons Phases, and a working Agent IDP in 90 days.

Four acts. Thirteen parts. Two hours end to end.

Short on time? Watch Act 2 alone, V to VI. That covers the demo and the architecture. Then jump to Act 4 for Discovery sign-off.

is the GenAI pilot failure rate measured by MIT NANDA in 2025. Failures concentrated in context, integration, and governance gaps. Not model quality.

Source: MIT NANDA, The GenAI Divide, State of AI in Business 2025.

of Agentic AI projects will be cancelled by end of 2027, according to Gartner. Cost overruns, unclear business value, inadequate risk controls.

Source: Gartner press release, June 2025. Same period when Gartner also forecast 40 percent of enterprise apps will feature task-specific AI agents by 2026, up from under 5 percent in 2025.

Developers estimated AI tools would speed them up by 20 percent.
An RCT measured they were 19 percent slower.

Source: METR, RCT on AI-augmented development, 2025. arXiv:2507.09089. When the tool makes you feel capable, you cannot detect it has made you less effective. Trust measured trajectories, not satisfaction surveys.

Three forms of debt accumulate in AI-native development.
Each is invisible until it is expensive.

Open Horizons exists to eliminate the Triple Debt by construction. SDD anchors intent, Backstage anchors knowledge, scope guards anchor scope.

Without a platform, every team pays four taxes.

An enterprise where the platform multiplies leverage, not headcount.

Four questions most enterprises fail to answer with precision.
Open Horizons answers each one in code, not in slides.

Two recurring pushbacks. Both have crisp answers from the field.

The 4-layer model is the teaching frame. The 6-layer model is the operating frame. Both are correct. They serve different rooms.

Open Horizons is an open-source Agentic DevOps Platform.
An Azure-native accelerator that gives enterprises a production-grade Internal Developer Platform and an AI Agent Platform in one coherent stack.

Delivered by Microsoft and the certified partner network. Deployed in your tenant, your subscription, your data. No SaaS, no lock-in, no per-seat pricing.

Four things Open Horizons is deliberately not.

Both personas share identity, catalog, RBAC, and observability.
An agent is just another component that needs to be managed, secured, and measured.

Twelve concerns. Four families. One coherent platform.

Four terms the executive team must agree on before signing a platform charter.

Every IDP, including Open Horizons, must deliver these.

The single biggest mistake is treating platform as an infra project.
It is a product. Developers and agents are both customers.

You cannot improve what you do not measure. Two frameworks, shipped out of the box.

DORA measures the system. SPACE measures the people running it. Both surface in the same Grafana board, both gate platform releases.

Five mistakes that kill platforms. All preventable.

From autocomplete to autonomy in three release cycles.

Four properties of a minimum-viable agent.

GitHub Copilot ships the primitives. Open Horizons ships the enterprise control plane that unifies them.

GitHub Copilot ships the primitives. Open Horizons unifies them with your catalog, observability stack, policy engine, and existing IDP.

Open Horizons is built around these four. Every customer inherits them.

What enterprises are doing with Open Horizons agents right now.

These are not demos. They are production agents running in customer environments with identity, governance, and cost controls.

Every failure mode below is a governance failure, not a model failure.

Open Horizons solves the governance failure. The model gets to do its job.

Twenty years, three definitions. Each one adds, none removes.

Source: Microsoft. Each layer survives. Agentic DevOps requires DevSecOps requires DevOps.

One platform across the full software lifecycle. Policy and governance wrap every stage.

Source: Microsoft. Open Horizons consumes this stack and wires it into Backstage. Every named asset above appears in the catalog with an owner.

Three workflows. Code, Collaborate, Operate. Each one is the agent + the human working the same surface.

Six concrete loops where GitHub + Azure remove a class of integration work.

App platform for a multi-model world. The model + agent + observability surface Open Horizons consumes.

Open Horizons consumes Foundry Models for inference, Foundry Agent Service for orchestration, and Foundry Observability as the data source for the L6 harness telemetry.

Four phases that turn a vague idea into a verifiable spec, ready for agent execution.

CONSTITUTION.md      # non-negotiables
SPECIFICATION.md     # EARS reqs, user stories
PLAN.md              # architecture, data models
TASKS.md             # 22 reviewable units
DIAGRAMS/            # 4 mermaid + 2 svg
ADRs/                # decision records

@implementer picks T-001..T-022 in sequence
@reviewer   gates each PR against SPEC
scope-guard blocks file edits outside .specs/042-*

Source: spec-kit pattern, used by Microsoft Specky and Open Horizons SDD pipeline. The spec is the contract between human intent and agent execution.

The starter menu. What every team uses on day one, before the first agent ships.

Source: Microsoft GitHub Copilot fundamentals. Open Horizons treats these as the on-ramp. Once teams adopt them, the next step is custom agents through Foundry Agent Service.

Five roles. Different prompts, same plumbing. The platform is one.

Four loops where GitHub + Azure AI Foundry produce outcomes neither delivers alone.

From "I need a new microservice" to "it is live in production." Seven steps, fully self-service.

Total developer effort: ~5 minutes of clicks. Total wall-clock to production: ~12 minutes. No tickets opened.

An agent is invoked by an event. The harness wraps the run. The trajectory lands in the catalog.

Every step is recorded. The agent never bypasses the harness. The trajectory is what the auditor reads.

A single PR. Two collaborators. Same catalog, same governance. The developer writes intent, the agent writes the boring part.

The platform refuses to record an agent action without a PR + spec link, and refuses to record a human action without a PR + reviewer. Same governance, both sides.

Six entry points covering the full developer + agent workflow.

28 capabilities across 3 pillars, measured from Traditional (L0) to Agentic (L4).

Where most LATAM enterprises score today across the four engineering layers.
Pre-platform vs post-H2 Open Horizons.

Maturity is decided by the weakest layer. The radar makes that visible. H1 lifts Infra, H2 lifts Platform, H3 lifts Context and Intent together.

Two dials every platform team should read weekly. Intent debt and token spend distribution.

L4 measures whether agents are still doing the right thing. L6 measures how much it costs. Both numbers belong in the platform team's Monday review.

Six layers, top to bottom. Intent flows down, telemetry flows up.

Intent flows from L4 down into Golden Paths in L2 and agent behavior in L3. The harness in L6 wraps every model call. Integration in L5 is how GitHub, Azure DevOps, Argo CD, and MCP coexist. Everything sits on the Terraform-managed Azure foundation.

The compute substrate. Eighteen Terraform modules, declared and reproducible.

All resources tagged with customer_name, environment, cost_center for L1 + L6 FinOps roll-up.

The developer experience layer. Upstream Backstage on AKS, 22 Golden Paths, full observability.

This is the layer that makes the developer productive. Agents consume L3 on top of it.

Give agents the right context, at the right time, in the right format.

Translate human intent into specifications the system can execute reliably.

Make GitHub, Azure DevOps, Argo CD and MCP coexist under one platform.

The runtime that wraps every model call. With L6, the agent becomes a governed production system.

Six layers, dedicated dashboards each. Data sources, Prometheus, Loki, App Insights, Azure Cost API, PostgreSQL.

Every dashboard has Alertmanager rules in prometheus/alerting-rules.yaml. The platform refuses to operate without observability, CI gates enforce dashboard + alert presence.

The CFO view. L1 cloud spend + L6 AI spend, one board.
Closes the "AI is unaffordable" objection before it leaves the room.

Each phase builds on the previous. No customer is asked to commit to H3 before H1 works.

Naming note. These are the Open Horizons Phases. They are not McKinsey's "Three Horizons of Growth" strategy framework.

Stand up a production-grade Azure environment with Backstage, GitOps, and observability.

Turn the foundation into a product application teams adopt voluntarily.

Success criteria, 80 percent of new services via Golden Path. Every PR gated by tfsec, Trivy, OPA. FinOps dashboard with attributed spend.

Make agents first-class platform citizens. Move from AI assistants to production agentic systems.

Success criteria, at least 5 production agents each with >100 trajectories/week. Per-agent cost attribution is exact and auditable. A failed run replays deterministically.

Day 0 to Day 180+, three stages, three outcomes.

Each phase delivers value on its own. Each one multiplies the value of the next.

Customer chooses. Platform abstracts.

Seven steps from "Create new service" to live in production.

Six steps. Same outcome, ADO-native plumbing.

A single Backstage catalog discovering entities from both sources. Dual auth. Single agent plumbing.

Five non-negotiables across A, B, and C.

DevSecOps tenet "everything as code" made operational, by Open Horizons defaults.

The opinionated, paved, well-lit road for the most common developer journeys.
Fully scaffolded, fully wired, ready to ship.

Term coined at Spotify. Operationalized in Open Horizons as Backstage Software Templates that produce a working repo, pipeline, infrastructure, observability, and catalog entry, in a single click.

Production-ready on Day 1. Twelve artifacts wired together, four families.

One Backstage Software Template, one click, twelve artifacts ready to ship. The platform did the boilerplate so the developer never has to.

22 paths today, organized by Horizons Phase.

Stepping off the path is supported. The platform never punishes deviation, only requires it to be explicit.

If a service needs a catalog entry, an owner, RBAC, observability, cost, and a runbook, so does every agent.

apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name:        deploy-orchestrator
  tags:        [agent, llm, production]
spec:
  type:        agent
  owner:       team-platform
  lifecycle:   production
  system:      agent-idp
  model:       gpt-5-1
  cost_center: cc-platform
  entrypoint:  https://agents.ohorizons.ai/api/agents/deploy
  runbook:     backstage.ohorizons.ai/docs/.../deploy-runbook
  policies:    [policy-net-egress, policy-budget-50usd]

Every agent is discoverable, attributable, and auditable through the same UI developers already use for services.

Same stages as any component, with AI-specific checkpoints.

No agent runs on a human's credentials. Period.

Every agent invocation produces a structured, replayable record.

Trajectories are stored in PostgreSQL + Loki, indexed, replayable, exportable to OpenTelemetry, and surfaced in Backstage. Without them, you have no debug story.

The single fastest way to lose executive trust in AI is a surprise bill.
Open Horizons prevents it with six controls.

Each maps to NIST CSF, ISO 27001, CIS, SOC 2.

Every risk has a structural mitigation.

Nine frameworks mapped. Evidence exported to a tamper-evident store on a schedule.

"How did this change reach production?" Answered in seconds, end to end.

Every link in this chain is immutable, timestamped, and signed.

A complete business case quantifies all three.
Plug your own numbers in. That is the only credible business case.

Compare against what you would build yourself, or a closed SaaS IDP.

The accelerator typically pays for itself inside the H2 window through productivity and consolidation savings alone.

Same scope of platform. Three timeframes. Customer's choice.

The compression is the entire business case. Same scope, three speeds, customer's choice.

Each step has a decision gate. Customers can stop, pause, or scale at any gate.

To start a Discovery, the customer needs six things. Everything else is provided.

Five deliverables before the first sprint starts.

Six failure modes, all preventable with the staged model.

Often in combination. Always with customer ownership intact.

Three tiers, based on demonstrated outcomes, not paid status. Renewed annually.

Four boundaries that protect the customer.

A five-step procurement pattern that keeps incentives aligned.