Skip to content

Frequently Asked Questions

This page separates released behaviour from future direction. For exact commands, providers and version-specific behaviour, the installed Runtime and technical documentation are authoritative.

What is Engineering Runtime?

Engineering Runtime is the Engineering Execution Layer for reusable engineering operations. It applies deterministic runtime decisions and supported policy, safety, authentication and evidence controls.

Humans, CI/CD, automation and AI agents can invoke the same provider operation or reusable Engineering Capability. Runtime applies its execution contract around that request: compiled safety, configurable policy, authentication/context, execution, sanitization, structured results and audit/evidence.

What problem does it solve?

Engineering systems already expose useful APIs and CLIs. The problem is that the same engineering operation is often reimplemented separately for a human, pipeline, automation system and AI agent.

Engineering Runtime aims to give those callers one reusable execution contract rather than four drifting implementations.

Is it just another CLI or wrapper?

No, although some Runtime paths intentionally use native CLIs underneath.

For one command typed by one engineer, engrt can look wrapper-like. The distinction appears when an operation must be reused under the same safety, policy, auth/context, result and evidence contract across different callers and transports.

The provider tool still performs provider-specific work. Runtime owns the governed execution boundary around it.

Does Engineering Runtime replace provider tools?

No.

GitHub, cloud platforms, Kubernetes, Terraform and other engineering systems remain authoritative for the resources and state they own. Runtime integrates their APIs, native CLIs and files rather than replacing those systems.

Which execution engines exist today?

The current Runtime has four execution engines:

  • REST
  • GraphQL
  • Command
  • File

Authentication/context and policy/audit are cross-cutting services, not additional dispatch engines.

Which providers are available today?

The released provider set is documented at docs.engineeringruntime.com/providers.

For the version you intend to install, check the published provider reference and release notes. Provider breadth is intentionally smaller than the long-term architecture.

Which operating systems are supported?

The qualified operating systems and architectures are listed in the installation guide for the approved stable release.

Install from the public release archives, shell installer or Homebrew. See the installation guide for platform-specific setup and checksum verification.

What is the executable called?

The current executable is:

engrt

Windows uses engrt.exe. Runtime-owned environment variables use ENGRT_*, and the default Runtime Home is ~/.engrt.

Earlier releases used different names; there is no promise that old aliases are automatically migrated.

Is Engineering Runtime open source?

No. Engineering Runtime is proprietary software.

The capability ecosystem can contain public or private Markdown capabilities, but public capabilities do not make the Runtime source open source.

Is Engineering Runtime free?

The Community Runtime is intended as the no-paid-license local product surface.

Release access, packaging and commercial terms are separate concerns and may change. The website should not infer anonymous download availability merely from a free edition or published documentation.

Does Runtime require a central server or Control Plane?

No.

The Runtime is local-first and can execute without a Control Plane.

The Control Plane is an optional governance direction for fleet-level management; it must not become a dependency for local execution.

Does Runtime require AI?

No.

The same execution contract can be invoked by:

  • humans,
  • CI/CD,
  • automation,
  • AI agents.

AI is a reasoning/interface layer, not a Runtime dependency.

Why separate reasoning from execution?

Reasoning systems are useful for understanding intent, planning and authoring new knowledge.

Execution infrastructure has a different responsibility: decide whether the operation is admitted, resolve identity/context, execute through an approved transport, sanitize results and preserve evidence.

Reason with AI. Execute with Runtime. Deterministically.

Why not let an AI agent execute arbitrary shell commands directly?

Direct shell execution does not automatically provide a shared Runtime contract for compiled safety, policy, identity/context, sanitization and evidence.

Engineering Runtime gives approved command execution the same governed boundary used by other transports. It does not claim to make arbitrary agent shell access safe.

What is the compiled safety floor?

The compiled safety floor contains Runtime protections that are part of the binary's execution contract rather than optional organisation policy.

Configurable policy can deny more. It must not be able to permit an operation the compiled safety contract refuses.

Policy may narrow the execution surface. It cannot expand beyond the compiled safety floor.

What is an Engineering Capability?

An Engineering Capability is reusable engineering knowledge expressed as a Markdown execution contract.

It declares inputs and ordered Runtime/provider steps. Newer capability contracts may also declare bounded typed outputs, conditions and live verification behaviour where the installed Runtime supports them.

A capability is not an AI prompt and does not depend on the model that authored it.

Can AI help author a capability?

Yes.

The released product exposes engrt capability authoring-context, which tells a human or assistant where the installed Runtime's exact authoring contracts live and which source is selected.

The recommended flow is:

search existing capability
  → read installed contract
  → author
  → validate
  → plan/inspect
  → execute
  → inspect structured result/evidence
  → review/version in Git

AI-assisted authoring does not bypass Runtime validation or execution controls.

What are capability version and Runtime compatibility?

They solve different problems.

  • Capability version identifies the evolution of the reusable engineering knowledge itself.
  • Runtime compatibility states which engrt versions the capability expects to understand its contract.

Compatibility metadata makes support explicit; it does not guarantee indefinite support without tests, qualification and migration policy.

What is stateless reconciliation?

For supported state-aware capability shapes, Runtime can observe authoritative provider state on every run, compare it with the declared intent, apply only required mutations, and verify the final state.

The new run does not depend on a Runtime-owned resource-state database or checkpoint from the previous run.

The capability author must choose steps whose contracts support observation and verification. Runtime does not invent desired-state semantics from arbitrary commands.

What do SATISFIED, APPLIED and RECONCILED mean?

For v0.11.0's bounded live-state model:

  • SATISFIED — authoritative state already matched the declared intent; no mutation was required.
  • APPLIED — missing intended state was created/applied and verified.
  • RECONCILED — observed drift was safely corrected and verified.

Not every operation supports these semantics.

What is live verification?

Execution success and state correctness are different.

Live verification performs a bounded read against the authoritative provider after the operation and compares the observation with the declared expectation.

A provider returning a successful mutation response is not, by itself, proof that the intended final state exists.

Does Runtime keep its own state file?

Runtime keeps contracts, audit/evidence and private working state in Runtime Home.

For v0.11.0's stateless rerun model, however, Runtime does not use a cross-run resource-state database as the authority for provider resources. The provider remains authoritative and is observed again on each run.

What is Runtime Home?

Runtime Home is the Runtime-owned local workspace, by default:

~/.engrt

It holds release-owned contracts and Runtime operational state such as audit/evidence, logs and private working data. Native provider credentials and user governance are owned separately.

What is a self-describing Runtime?

Each Runtime release ships contracts describing the command surface, capability grammar and provider operations supported by that release.

This allows humans and AI assistants to author against the installed binary rather than relying on stale training data or a different release's documentation.

How does MCP fit?

MCP can fit in two different directions:

  1. Runtime may consume a bounded MCP surface as another provider/transport path.
  2. Runtime may eventually expose governed Runtime artifacts or operations to agents through MCP.

Those are separate architectural directions. MCP does not become a second auth/policy/result authority.

Are Capability Packages or a public Capability Registry available?

No generalized public Runtime registry is part of the current product.

Current capability distribution is Git/file based: users point Runtime at explicit capability sources/checkouts.

Packaging, registry and signed-distribution ideas are future direction and should not be described as shipped until they are implemented and qualified.

What is GitHub-as-Agent-Context?

It is an Engineering Runtime operating model in which durable engineering context is written into versioned GitHub artifacts such as issues, commits, branches, pull requests, decisions and evidence.

Agents do not just share context. They inherit versioned context.

GitHub preserves context/coordination; Engineering Runtime governs execution.

What is the long-term vision?

The vision is broader than the current release:

Engineering knowledge should become reusable execution, not repeated implementation.

The long-term direction is a growing body of reusable, reviewable and versioned Engineering Capabilities over a stable Engineering Execution Layer.

Future direction is intentionally allowed to be ambitious. Claims about current technical behaviour remain bounded by released implementation and evidence.