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

03 · Governance and AAA

Authorize the caller, the resource, and the runtime action.

NopsAI combines product roles with low-level authentication, authorization and audit controls. Runtime checks stay caller-scoped across users, repositories, services and scheduled work.

Default denySensitive product and runtime actions
Caller scopedUsers, repositories, services and schedules
Deny firstPolicy evaluation before allow decisions

How it works

Governance and AAA, end to end.

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

  1. Authenticate the subject

    Resolve a local session, OIDC identity, personal token, service-account token, repository identity or internal service identity.

  2. Expand product intent

    Product roles and folder grants map to low-level AAA actions and inherited resource paths.

  3. Evaluate each boundary

    NopsAI checks route access and runtime use of pipelines, scopes, steps, secrets, variables, knowledge, runners and tools.

  4. Record the decision

    Denied and sensitive allowed operations are written to authorization and product audit records.

Identity and access screen showing users with team-scoped roles such as developer, owner and viewer per team path.

Platform capabilities

What teams can standardize.

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

Enterprise identity

Local authentication, JWT sessions, personal tokens, service accounts and OIDC-backed identity providers.

Inherited access grants

Apply viewer, developer, owner or admin intent at a team path and inherit it through the hierarchy.

Resource-use authorization

Check protected references at run creation instead of relying only on route-level access.

Approval separation

Assign approval teams and optionally prevent users from approving their own gated work.

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.

access/all.yamlYAML
users:
  - sub: alice
    email: [email protected]
    advanced_roles: [release-manager]

service_accounts:
  - sub: release-scheduler
    email: [email protected]

advanced_roles:
  - name: release-manager
    policies:
      - resource: pipeline:platform/*
        action: pipeline.execute

basic_roles:
  - user: alice
    role: owner
    resource: team:platform
  - service_account: release-scheduler
    role: developer
    resource: team:platform/prod

Enterprise controls

Configuration stays inside the governance model.

Policy service with fallback

The standalone AAA decision service is primary, with a compatible in-process evaluator for temporary outages.

Scope isolation

Scoped variables and secrets resolve only from the requested scope chain; scoped runs do not fall back to unscoped values.

Secret masking

Resolved secrets are protected in storage and masked from agent logs and execution history.

Service authentication

Dispatcher, runner, agent and internal callbacks use explicit service identity rather than user impersonation.

Bring a real governance and aaa workflow.

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