Platform

Platform overviewWorkflow orchestrationGitOps configurationGovernance and AAAAI and MCPRuntime and executionEvidence and monitoring

Use cases

All use casesProduction incidentRelease preparationHotfix to productionSecurity scan triage
Why NopsAIIntegrationsSecurity

Resources

All resourcesAI agent governanceMCP governanceMCP securitySelf-hosted platforms
Pricing

Company

How a run worksAboutContactBook a demo

01 · Workflow orchestration

Orchestrate deterministic and AI work in one governed DAG.

NopsAI treats AI-assisted work as part of a durable pipeline run. Dependencies, conditions, timeouts, approvals, context and outputs stay explicit from trigger to completion.

One DAGScripts, AI goals, approvals and includes
Per runDurable context, status, logs and outputs
ExplicitDependencies, conditions and timeouts

How it works

Workflow orchestration, end to end.

The flow stays explicit enough for operators to inspect, secure, automate and improve.

  1. Normalize the signal

    Git events, schedules, APIs, manual actions and external triggers become one consistent run request.

  2. Resolve the definition

    NopsAI loads pipeline YAML, reusable steps, knowledge context, scope, variables, secrets and access decisions.

  3. Execute the graph

    The agent advances dependency-aware tasks, pauses at approvals and delegates work to isolated step runtimes.

  4. Attach the outcome

    Status, logs, task history, approval decisions, AI usage and declared outputs stay owned by the run.

A pipeline run graph with deterministic steps, an AI-assisted step, a policy check, a security scan and a final approval gate.

Platform capabilities

What teams can standardize.

These are current NopsAI platform primitives, not a future-state feature list.

Mixed execution steps

Use script tasks and LLM-backed goals in the same pipeline without hiding either execution path.

Reusable composition

Include reviewed shared steps or trigger child pipelines while preserving parent-child run history.

Human approval gates

Pause a run without holding a runner, then resume from persisted history and workspace state.

Run-owned deliverables

Generate Markdown, JSON, HTML, PDF, Excel or dashboard outputs after the pipeline completes.

Configuration

Declared once, reviewed like code.

The example is declarative and Git-reviewable. Runtime behavior still passes through live AAA, credential, compatibility, execution and monitoring boundaries.

pipeline.yamlYAML
name: release-readiness
version: "1.0.0"
container_image: golang:1.24
agent_profile: release-manager
llm_profile: reasoning
knowledge_context:
  - kind: policy
    ref: platform/release
    required: true
steps:
  - name: validate
    include: step:platform/shared/release-checks
  - name: review
    depends_on: [validate]
    goal: Summarize release risk and propose a decision.
    mcp_profiles:
      - github-readonly
  - name: approve
    depends_on: [review]
    approval:
      type: production-release
      teams:
        - platform/prod
      allow_self_approval: false
      timeout: 24h
output:
  items:
    - name: Release brief
      type: markdown
      when: always
      prompt: |
        Summarize the release decision, the supporting
        evidence, and the approver.

Enterprise controls

Configuration stays inside the governance model.

Authorization before dispatch

Caller-scoped checks cover the pipeline and every protected resource referenced by the run.

Reviewable configuration

Pipeline and reusable-step definitions stay in Git with normal review and promotion controls.

Bounded AI access

Agent, LLM and MCP profiles are selected explicitly rather than constructed dynamically by a task.

Observable execution

Task state, logs, output generation, runner behavior and AI usage feed the same monitoring model.

Bring a real workflow orchestration workflow.

We can map the configuration, authorization, runtime and evidence boundaries against your current platform model.