Latest stable releaseInstall and supported platforms

Reason with AI.
Execute with ENGRT.

ENGRT is the Engineering Execution Layer. Turn repeatable operations into reusable capabilities that humans, CI/CD, automation and AI agents run under one contract for authorization, policy and evidence.

Free Community Runtime · No account or server needed

How Engineering Runtime fits in Illustrative architecture: engineers, AI agents, CI/CD and automation send work to Engineering Runtime. A shared execution boundary applies capabilities, context, policy, authentication and audit for operations against supported systems. GitHub, cloud platforms, Kubernetes, Jira and ServiceNow, APIs and internal systems illustrate present and potential integrations; not all depicted providers or operations are released or qualified. REST, GraphQL, command-line and file interfaces are execution paths; MCP is another integration path, not a bypass of the boundary. FROM INTENTTO EXECUTION DETERMINISTIC · GOVERNED · AUDITED PREPARE EXECUTE ENFORCE RECORD Engineering Runtime EXECUTE · GOVERN · AUDIT Capabilities Auth Context Policy Audit EngineersOPERATORS · TEAMS AI agentsASSISTANTS · COPILOTS CI/CDBUILD · TEST · DEPLOY AutomationSCRIPTS · SCHEDULES · JOBS GitHubREPOS · PULL REQUESTS CloudAWS · GCP · AZURE KubernetesGKE · EKS · AKS Jira · ServiceNowISSUES · CHANGES · INCIDENTS APIsTHIRD-PARTY · CUSTOM Internal SystemsDATA · TOOLS · PLATFORMS Your next providerREST · GRAPHQL · CLI · FILES DESIGNED TO EXTEND TO ANY SYSTEM WITH AN INTERFACE
How Engineering Runtime fits in Illustrative architecture: engineers, AI agents, CI/CD and automation invoke Engineering Runtime, which applies capabilities, context, policy, authentication and audit to operations through approved interfaces. The depicted provider categories include future direction and are not a statement that every integration is released or qualified. FROM INTENT TO EXECUTION Engineering Runtime EXECUTE · GOVERN · AUDIT Capabilities Context Policy Auth Audit Engineers AI agents CI/CD Automation GitHubREPOS · PULL REQUESTS CloudAWS · GCP · AZURE KubernetesGKE · EKS · AKS Jira · ServiceNowISSUES · CHANGES · INCIDENTS APIsTHIRD-PARTY · CUSTOM Internal SystemsDATA · TOOLS · PLATFORMS Your next providerREST · GRAPHQL · CLI · FILES DESIGNED TO EXTEND TO ANY SYSTEM WITH AN INTERFACE

One governed boundary Operations through REST, GraphQL, native CLI and file interfaces follow Runtime policy, identity/context and audit controls. MCP is an integration path, not a separate execution trust boundary.

Scope of the diagram The provider landscape above illustrates the architectural direction, not a claim that every depicted provider or operation is available or qualified today. Check supported providers and operations →

Supported paths today GitHub APIs · local files · selected reviewed native CLI modes including kubectl, terraform and gcloud. Exact commands and targets are subject to admission.

Practical starting point · GitHub repository governance

Make repository standards repeatable, not another checklist

Platform teams need consistent repository settings and a reliable way to review change. ENGRT capabilities let teams express repeatable GitHub operations through a governed execution path instead of asking every engineer, CI job or AI agent to rebuild the same procedure.

Observe and plan

Inspect the target repository, identify which standards need attention, and review the proposed operations before execution. Availability of live checks and plans depends on the specific capability and Runtime version.

Execute under control

Run approved GitHub operations using supported authentication and interfaces, with policy decisions and audit evidence at the Runtime boundary. Permissions and provider limitations still apply.

Verify the outcome

Where a capability defines authoritative observation and verification, inspect the resulting provider state and distinguish satisfied, applied or reconciled work. Not every workflow offers automatic reconciliation.

Use existing tools

GitHub remains the source of truth for repository state. ENGRT adds reusable execution contracts and governance; it does not replace GitHub or promise blanket support for every API operation.

This is a use-case walkthrough, not a recorded production deployment or a claim that all GitHub governance operations are qualified. For released capabilities, prerequisites and known limits, consult the provider documentation and capabilities overview.

30-second product read

What Engineering Runtime is — and why it exists

Engineering Runtime is the Engineering Execution Layer for operations against real systems. Humans, CI/CD, automation and AI agents can invoke the same reusable capability while Runtime applies one execution contract for policy, authentication, context, sanitization and audit. Engineering platforms are the first proving ground, not the product boundary.

Who needs it

Anyone building reliable execution for humans, CI/CD, automation or AI agents across real systems. Platform and engineering teams are an initial wedge, but the Runtime model is broader: reasoning can stay flexible while execution follows one deterministic, governed and evidenced contract.

Why now

AI can increasingly understand engineering intent and invoke tools. The harder problem is moving from reasoning to real infrastructure without giving every caller a different auth, policy, context and audit path.

What is already built

A working local Runtime with REST, GraphQL, Command and File engines; reusable capabilities; GitHub API execution; approved native CLI execution; policy checks; structured results; and local audit/evidence.

Why this approach

The product does not replace provider tools. It puts one governed execution boundary around them: reasoning stays with humans or AI; execution guarantees stay with Runtime. Why I am building it →

How it works

From install to your first capability

  1. Install the Runtime

    One local Runtime for macOS, Linux and Windows. No account or server.

    brew install engineeringruntime/tap/engineering-runtime

    Or the shell installer (macOS/Linux):

    curl -fsSL https://raw.githubusercontent.com/engineeringruntime/engineering-runtime-releases/main/install.sh | sh

    Windows, archives and checksum steps: installation guide.

  2. Write a capability

    Describe a repeatable engineering operation as a Markdown capability with a deterministic Runtime block. Capabilities can live with the team that owns them and be reviewed like code.

  3. Invoke the same operation

    A human, CI job, automation or AI assistant can request the capability. The caller reasons about intent; Runtime performs the deterministic execution, checks policy first and records the outcome.

first run — engrt, illustrative output trimmed
$ engrt bootstrap
Runtime Home: ~/.engrt
Runtime is ready.

# inside the working directory: allowed
$ engrt files write ./notes.txt hello
Status:     success
Message:    wrote 5 bytes to notes.txt

# outside it: refused before anything runs
$ engrt files write ../outside.txt hello
Status:     denied
Execution:  not dispatched

# verify the retained evidence chain
$ engrt --output json audit verify
{ "intact": true, ... }

How Runtime reaches your platforms

Four execution engines. One governed boundary.

Runtime uses four execution engines: REST, GraphQL, Command and File. MCP is a separate integration path: an experimental inbound GitHub read calls the same Runtime, while outbound provider MCP is still being qualified. ENGRT works with your existing systems; it does not replace them.

REST

HTTP APIs

Today: GitHub

GraphQL

GraphQL APIs

Today: GitHub

Command

Approved CLIs

Today: selected, reviewed modes of gh, gcloud, kubectl and terraform. Binary allowlisting alone does not permit arbitrary commands.

File

Files and config

Today: the files provider

MCP

Experimental agent interface; provider transport in development

Experimental: one read-only GitHub repository-view MCP tool over local stdio. Broader inbound and outbound support is not yet released.

The four released engines use Runtime admission, applicable authentication/context, policy, compiled safety and evidence. The experimental inbound MCP tool calls the same Runtime; outbound provider MCP remains under qualification. How providers use engines →

What Runtime provides

Governed automation without the rewrite

One implementation, every caller

Engineers, CI/CD, automation and AI agents run the same capability — not four copies that drift apart.

AI without vendor lock-in

AI stays on the reasoning side of the boundary. Runtime exposes a deterministic contract that assistants can invoke through supported execution surfaces without making the model the executor.

Policy before execution

Supported operations pass Runtime admission, policy and compiled safety checks before dispatch. Invalid, unknown or prohibited requests can be refused earlier.

Audit by default

Supported paths record local decisions and execution evidence for inspection and verification. Incomplete or failed audit evidence must be reported truthfully.

Reusable execution for agents

Do not make every agent rediscover solved engineering execution

Capabilities capture engineering intent once so humans, CI/CD, automation and AI agents can reuse the same governed execution. The long-term direction is capability-first: search and reuse a trusted capability when one already exists, author and validate one when it does not, and preserve proven execution as reusable engineering knowledge.

Reuse before re-reasoning

Solved operations should become durable capability knowledge instead of being regenerated as fresh shell or Python on every run.

Reasoning stays flexible

Humans and AI decide what should happen. Runtime owns the bounded execution contract that reaches the real system.

Engineering Runtime · Long-term vision

Executable Engineering Standards.

Turn your organisation's engineering standards into reusable, governed and verifiable execution.

Beyond running a script: encode approved procedures as reusable capabilities, enforce execution boundaries, and verify the resulting state. This is a product direction, not a claim of complete standards enforcement today. Explore the vision →

Execution evidence

Verify against reality where proof matters

For operations with explicit observation and verification semantics, Runtime can read authoritative provider state before and after execution, distinguish already-satisfied work from applied or reconciled work, and record evidence of the resulting state. Runtime does not claim that arbitrary opaque workflows are automatically retry-safe.

5execution engines
1local Runtime binary
0accounts or servers to start

Intent can start anywhere.
Execution stays deterministic.

Free Community Runtime for macOS, Linux and Windows. No account or server required.