Deployment control for consequential AI

The control planeto govern

Move AI systems from experiment to production with named owners, explicit policy, reversible releases, and an audit trail that stays attached to every change.

POLICYchecked before releaseCONTROL 01
OWNERnamed at every gateCONTROL 02
ROLLBACKplanned before promotionCONTROL 03
AUDITcontext retainedCONTROL 04
POLICYchecked before releaseCONTROL 01
OWNERnamed at every gateCONTROL 02
ROLLBACKplanned before promotionCONTROL 03
AUDITcontext retainedCONTROL 04
Capabilities

Control what moves.
Understand why it moved.

01

Policy-bound releases

Attach model, data, tool, and environment policy to a release before it can move beyond staging.

02

Evaluation evidence

Keep test suites, reviewer decisions, and known limitations beside the exact system version they describe.

03

Human release gates

Route sensitive changes to the right owner, record the decision, and make exceptions visible instead of implicit.

AB
04

Operational boundaries

Scope tools, credentials, data access, and runtime permissions independently for each AI system and environment.

Process

Three deliberate steps.
No invisible hand-offs.

workflow.ts
1import { arcwise } from '@arcwise/control'
2
3arcwise.define({
4  system: 'support-router',
5  tools: ['knowledge.read'],
6  escalation: 'human-review'
7})
Concept preview
Environment model

Boundaries by
default.

Arcwise treats every environment as a distinct contract. Data, tools, approvals, and rollback rules travel with the release instead of living in a separate checklist.

01
Policy source
02
Approval modes
06
Release stages
Release boundaryInterface preview
Sandbox
Synthetic data only
Isolated
Development
Developer-owned tools
Observed
Evaluation
Recorded test suites
Evidence
Staging
Production-like boundary
Restricted
Approval
Named risk owner
Required
Production
Versioned permissions
Audited
Reference model

Governance you
can inspect.

Product concept|Local time
0
Policy objects in this reference flow
0
Release stages illustrated
0
Approval paths mapped
0
Decision record per release
Connector map

Put existing systems
inside the policy boundary.

Reference connectors shown for interface planning. Availability depends on implementation.

GitHub
Source context
Slack
Approval surface
Stripe
Sensitive tool boundary
PostgreSQL
Data policy
Redis
Runtime state
AWS
Deployment target
MongoDB
Data policy
Vercel
Deployment target
Figma
Design context
Linear
Release record
Notion
Knowledge boundary
OpenAI
Model provider
GitHub
Source context
Slack
Approval surface
Stripe
Sensitive tool boundary
PostgreSQL
Data policy
Redis
Runtime state
AWS
Deployment target
MongoDB
Data policy
Vercel
Deployment target
Figma
Design context
Linear
Release record
Notion
Knowledge boundary
OpenAI
Model provider
OpenAI
Model provider
Notion
Knowledge boundary
Linear
Release record
Figma
Design context
Vercel
Deployment target
MongoDB
Data policy
AWS
Deployment target
Redis
Runtime state
PostgreSQL
Data policy
Stripe
Sensitive tool boundary
Slack
Approval surface
GitHub
Source context
OpenAI
Model provider
Notion
Knowledge boundary
Linear
Release record
Figma
Design context
Vercel
Deployment target
MongoDB
Data policy
AWS
Deployment target
Redis
Runtime state
PostgreSQL
Data policy
Stripe
Sensitive tool boundary
Slack
Approval surface
GitHub
Source context
Governance model

Control is
designed in.

Arcwise is presented here as a product concept—not a certified or operational service. The interface shows how release evidence and responsibility could stay legible.

POLICYEVIDENCEAPPROVALROLLBACKAUDIT CONTEXT

Policy checks

Evaluate the declared data, tool, and runtime boundary before a version can advance.

Least-privilege tools

Scope each system to the narrowest set of actions required for its assigned workflow.

Human checkpoints

Require a named decision when a release crosses a sensitive operational boundary.

Decision context

Retain evaluation results, exceptions, release notes, and rollback intent together.

SDK concept

Policy as code.
Review as a team.

A compact interface study for defining boundaries, attaching evaluation evidence, and requesting a release. The package and examples are illustrative only.

Typed policy

Model permissions as reviewable code.

Explicit defaults

Make inherited behavior visible.

Provider-aware

Keep model and runtime context together.

Evidence-linked

Trace decisions to the evaluated version.

// Illustrative API — not a live package
import { arcwise } from '@arcwise/control'
arcwise.define({
  tools: ['knowledge.read'],
  escalation: 'human-review'
})
Deployment doctrines
01 / 04

“A model version is not a release until its permissions, evidence, owner, and rollback path are visible together.”

B

Boundary

Control principle, Arcwise reference model

Control outcome

Explicit scope

Reference control vocabulary

MODEL VERSIONTOOL SCOPEDATA BOUNDARYEVALUATIONOWNERAPPROVALROLLBACKAUDIT TRAIL
MODEL VERSIONTOOL SCOPEDATA BOUNDARYEVALUATIONOWNERAPPROVALROLLBACKAUDIT TRAIL
Access model

Start with the
control boundary

A concept-stage structure for evaluating fit. No plans are currently sold through this preview.

Product viewControl viewConcept
01

Inspect

Map one AI system and its release boundary

Preview
  • System inventory
  • Tool and data boundary
  • Evaluation record
  • Named release owner
  • Rollback intent
Preview scope
Reference path
02

Govern

Coordinate review across a release path

Preview
  • Everything in Inspect
  • Environment-specific policy
  • Reviewer assignment
  • Exception register
  • Approval checkpoints
  • Release history
  • Illustrative SDK surface
Review concept
03

Operate

Extend the model across internal systems

Preview
  • Everything in Govern
  • Organisation policy model
  • Custom release topology
  • Connector assessment
  • Control ownership map
  • Incident context
  • Retention requirements
  • Implementation workshop
Discuss implementation

Product concept only. No account, contract, or paid service is created here. Review the control model

Ready to make
release risk visible?

Walk through the reference control model, then decide which policies, evidence, and human gates belong in your own release process.

Product concept · no live account or transaction