[ SOX / Program changes ]

AI workflows under change control

engini separates development, staging and production inside a workspace, ties each API key to one workspace and one environment, and lets you export workflows so the tested version is the one you promote and keep in version control. Your change tickets, testing and sign-off stay in your own process; engini gives them clean boundaries to work with.

ITGC: program changesCOBIT BAI06JiraGitHub
Read about engini skills →
A workflow change, promoted
  1. Change ticket openedin your ITSM, for example Jira
  2. Built in developmentdev environment, dev key
  3. Tested in stagingstaging environment, test data
  4. Exported to version controlthe tested definition, in your repo
  5. Imported to productionby a different person, with a production role
Illustration of the flow on this page, not a product screen.
What it is
Clean boundaries for changing AI workflows and agent tools
Control area
ITGC: program changes; separation of development and production
engini provides
Environments, environment-bound API keys, import and export, roles, audit log
You still own
Tickets, testing sign-off, who may promote, prompt and model versions
[ 01 / The problem ]

AI workflows change fast. Auditors still want the ticket.

Program change is one of the four IT general control areas the SEC names (Release 33-8810), and auditors rely on it before they can rely on automated controls. PCAOB inspectors have repeatedly found that audit teams did not evaluate whether changes to accounting systems were tested before production, or test the completeness of the population of changes (PCAOB, 2024).

AI workflows make this harder. A workflow that posts vendor bills or a toolset that lets an agent update records is a program change in every sense, but it can be edited in minutes, often by the same person who will run it. ISACA says agent logic should be treated as code, under version control (ISACA, 2025).

What the auditor will ask

  • Is the workflow running in production the version that was tested?
  • Who can change production, and is that someone other than the developer?
  • Can you give me the complete list of changes in the period?
  • Are development and production credentials separate?

What engini gives your change process

Inside a workspace, engini keeps separate development, staging and production environments. API keys are tied to one workspace and one environment, so a development key cannot touch production. Workflows can be exported and imported, so the definition you tested in staging is the one you promote, and the export can live in your own repository as the change record. Roles, including custom roles, decide who can edit where, and the audit log records activity.

engini does not run your change tickets or hold a workflow for sign-off; it has no approval step. Keep the ticket, the test evidence and the approval in your ITSM, and use engini’s boundaries to make the promotion clean. Prompts inside a third-party chat client and model versions change outside engini, so manage them in your agent platform.

[ 02 / How it works ]

A change path your auditor can walk

engini provides the boundaries. The ticket and the sign-off live in your ITSM.

01 / Ticket

Open the change

Every change to a workflow, toolset or MCP server that touches financial systems starts with a ticket in your ITSM.

02 / Build

Develop and test apart

Build in development and test in staging, each with its own environment-bound API key and connections to test systems.

03 / Record

Export the tested version

Export the tested workflow and commit it to your repository, so the change record is the actual definition.

04 / Promote

Someone else imports it

A person with a production role, not the developer, imports it to production. Reconcile changes against the audit log each period.

[ 03 / What the agent reads and writes ]

Where each part of the control lives

SystemRecordsAccess
engini environmentsDevelopment, staging and production inside a workspaceSeparate
engini API keysEach tied to one workspace and one environmentScoped
engini rolesWho can edit or import in each environment, custom roles includedConfigure
Your repositoryExported workflow definitions, versionedWrite
Your ITSMTicket, test evidence and sign-offYour process
[ 04 / Build it with the engini skill ]

Describe it in plain words. The engini skill builds the workflow.

engini skills is engini’s plugin for Claude Code and Codex. Its workflow agent, Flo, turns a plain-language request into an engini workflow: it designs the steps, dry-runs them against your own engini account, shows you a proposal, and creates the workflow only after you approve it, always turned off. You check it in the engini designer and turn it on.

Blurred landscape photo with the word change under the line "The tested version is the one you promote", and three labels: development, staging, production

Editorial image: development, staging, production, kept apart.

Claude Code: install once
/plugin marketplace add engini/skills
/plugin install skills@engini
Then ask for this solution
Build a workflow in my engini account: every Monday at 8:00, list workflows in the production environment that were changed in the last 7 days and post the list, with who changed each one and when, to #change-review in Slack.
  1. You need an engini account, the engini CLI (npm i -g @engini/cli) and a workspace-scoped API key, ideally a dedicated least-privilege one.
  2. Connect the systems this flow uses in engini first. Flo never creates or changes a connection and never handles your key; it tells you which command to run.
  3. Flo checks your login and workspace, searches the tool catalog, compiles the plan and shows a proposal table with every step. It creates the workflow only when you approve that proposal, and it creates it turned off.
  4. Open it in the engini designer, fill anything it left for you, and turn it on.
engini skills for Claude Code and Codex →
What the skill will never do on its own →
[ 05 / Agent Policy ]

Boundaries engini enforces, steps you own

Separated

Environments

Development, staging and production are separate inside a workspace, each with its own connections and workflows.

Scoped

Keys and roles

API keys are tied to one workspace and one environment. Roles, including custom roles, limit who can change production.

Recorded

Activity and runs

The audit log records activity and supports export and SIEM streaming; workflow run history shows what ran in each environment.

Your process

Not built in

engini has no change-ticket or approval step and does not version prompts or models. Those stay in your ITSM and agent platform.

SOC 2 Type IIISO 27001GDPRHIPAA compliant
[ 06 / Try it now ]

Build it on your own data today

Start free, connect your systems, and build this flow with the engini skill, in Workflow Studio, or from your own agent.

  • 01Workflow Studio. Build the flow on a visual canvas, with an AI agent step where judgment is needed. Start free →
  • 02Your own agent. Give Claude, ChatGPT or Cursor an engini MCP server with only these tools. MCP client setup →
  • 03The engini skill. Ask Flo in Claude Code or Codex and review its proposal. Install the skill →
[ 07 / Questions ]

Questions buyers ask before they start

Does engini separate development and production?

Yes. A workspace has separate development, staging and production environments, and each API key is tied to one workspace and one environment.

How do we prove production runs the tested version?

Export the workflow you tested in staging, commit it to your repository, and import that same definition to production. The export is your change record.

Can we stop developers from promoting their own changes?

Yes, with roles. Give developers rights in development and staging, and give production import rights to a different role.

Does engini have an approval step for changes?

No. Keep the ticket, test evidence and approval in your ITSM, such as Jira or ServiceNow, and use engini’s environments, roles and export to carry out the approved change.

What about prompt and model changes?

Prompts in a third-party chat client and model versions change outside engini. Manage them in your agent platform, and keep engini’s toolsets and MCP servers narrow so a model change cannot reach new tools.