Deploying what you built with Build Agent

  • Release version: Zurich
  • Updated May 6, 2026
  • 3 minutes to read
    • Summarize
    Summarized using AI
    This content was generated using new OpenAI-powered functionality. Results are provided on an as is basis and are not guaranteed to be accurate or complete.

    Summary of Deploying what you built with Build Agent

    This content guides ServiceNow customers on deploying applications built with Build Agent, detailing deployment workflows, methods, and tools to move apps from development to production. It emphasizes choosing deployment approaches based on app complexity and organizational needs, ensuring secure, controlled, and efficient releases.

    Show full answer Show less

    Deployment Workflow

    • Collaborative design: Business and IT teams collaborate on requirements using preferred tools.
    • AI-driven development: Build Agent and Now Assist generate and implement app updates from various inputs.
    • Review and testing: Teams preview, revise, and test app updates for performance and readiness.
    • Developer review: Developers validate AI-generated changes and confirm readiness.
    • Deployment approval: Deployment managers initiate approval processes.
    • Autonomous checks: AI agents scan for issues like data exposure and fix them before deployment.
    • Final deployment: After approvals and scans, the app is deployed securely.

    Important: Changes remain isolated until explicitly deployed, allowing safe iteration without impacting live applications. Isolation mechanisms vary by environment: source/build artifacts in ServiceNow IDE, and update sets in ServiceNow Studio.

    Deployment Methods

    • Git-based source control integration: Supports version control and CI/CD with ServiceNow IDE, enabling Git workflows (branching, merging, automated deployments) and integration with platforms like GitHub or Bitbucket.
    • Update sets and application packaging: Traditional method using System Update Sets to track and transport changes, with advanced packaging into scoped applications via Application Repository (AppRepo) for easier distribution.

    Moving Applications through Instances

    • Wrap scoped applications in update sets, convert to AppRepo, and publish with demo data for deployment requests or standard processes.
    • Publish apps to AppRepo via Git or update sets, enabling distribution across environments and integration with ReleaseOps pipelines that automatically run Automated Test Framework (ATF) tests.
    • Register and entitle apps before publishing to AppRepo to manage access and distribution.

    Additional Deployment Tools

    • App Engine Management Center (AEMC): Performs governance checks (ACLs, roles, compliance) and provides dashboards for deployment and version management. Works with ReleaseOps pipelines for controlled app movement.
    • ReleaseOps: Automates moving changes across instances with customizable playbooks, supports preview, commit, validation, ATF test execution, approval gates, and scheduling for controlled rollout.
    • ServiceNow SDK: Enables moving applications between instances and local environments via CLI, supporting integration with external CI/CD processes.
    • Automated Test Framework (ATF): Build Agent can generate ATF tests that run in ServiceNow Studio or IDE to verify app functionality post-changes.

    Learn about deployment methods and workflows for moving applications created with Build Agent from development to production environments. Choose the right deployment approach based on your application complexity and organizational requirements.

    Workflow for deployment

    After development, review, and testing are complete, a typical deployment workflow includes the following steps:
    1. Collaborative design: Business owners and IT collaborate on requirements and ideas using their preferred tools.
    2. AI-driven app development: Build Agent and Now Assist process files, chat history, and diagrams to generate and implement app updates.
    3. Review and testing: Teams preview updates, make revisions, and run rounds of performance and readiness testing.
    4. Developer review: A developer reviews the AI-generated changes, compares versions, and confirms the changes are ready for deployment.
    5. Deployment approval: The project is handed off to a deployment manager, who initiates the deployment approval process.
    6. Autonomous checks: AI agents automatically scan for issues (such as sensitive data exposure or model integrity problems) and remediate them before deployment.
    7. Final deployment: After all readiness scans and approvals, the new app is deployed securely and efficiently.
    Important:
    Changes are isolated until you explicitly deploy and install the application. You can modify and iterate without affecting the live running application.
    The way isolation works depends on the environment:
    • In the ServiceNow IDE, isolation runs through source and build artifacts until you deploy and install.
    • In ServiceNow Studio, changes are tracked in update sets and promoted when you move the update set between instances.

    Deployment methods for Build Agent

    Build Agent supports the following deployment methods for vibe-coded and AI-developed apps:
    • Git-based source control integration with ServiceNow IDE: ServiceNow supports Git-based workflows for version control and CI/CD.
      • You can push scoped apps to Git repositories, enabling branching, merging, and automated deployments. ServiceNow IDE supports bring-your-own Git integration, such as GitHub or Bitbucket.
      • For more information, see Integrating source control with the ServiceNow IDE.
    • Update sets and application packaging: Standard ServiceNow deployment uses System Update Sets to track changes.
      • Advanced guidance includes packing update sets into scoped applications for easier transport and installation across instances, for example using Application Repository (AppRepo).
      • For more information on System Update Sets, see System update sets.

    Options for moving apps through instances

    After you create an app using Build Agent, you have several options to move the app to the test instance.
    1. Wrap the entire scoped application in an update set. The workflow is as follows:
      1. Go to the Custom Applications list, select an app and swap to its scope.
      2. Convert the app to AppRepo.
      3. Publish the update set with demo data.
      4. Put the update set in a deployment request for ReleaseOps, or follow your standard update set process for deployment.
    2. Publish the app to AppRepo:
      • You can use a Git-based process or update sets to publish to AppRepo.
      • Scoped apps, as well as apps that are ready for testing, can be published to the AppRepo for distribution across environments.
      • After an app is in AppRepo, you can move it through a ReleaseOps pipeline. If ATF tests are included in the pipeline, they automatically run.
      • Register and entitle apps before publishing.
      • For more information on Application Repository, see ServiceNow application repository.

    Additional deployment tools

    The ServiceNow AI Platform has additional deployment tools that include the following tools:
    • App Engine Management Center (AEMC):
      • After developing an app, submit it to AEMC for governance checks.
      • AEMC validates ACLs, roles, and compliance settings before deployment.
      • Use ReleaseOps pipelines to move apps through environments with ATF tests and approval gates.
      • AEMC provides dashboards for monitoring deployments and managing app versions throughout the lifecycle.
      • For more information on AEMC, see Using the App Engine Management Center.
    • ReleaseOps:
      • Move changes from development to production through multiple instances using customizable playbooks.
      • Automate preview, commit, and validation of update sets before deployment.
      • Run Automated Test Framework (ATF) tests as part of the pipeline to validate quality.
      • Deploy changes immediately or schedule releases for controlled rollouts.
      • Enforce checks, scans, and approvals before production deployment.
      • For more information on ReleaseOps, see ReleaseOps.
    • ServiceNow SDK:
      • Use the ServiceNow SDK to move applications to and from your instance to your local machine. You can integrate the ServiceNow SDK with your off-instance CI/CD process if you have one.
      • Install the ServiceNow SDK locally and use the command line interface (CLI).
      • Authenticate to a ServiceNow instance from the ServiceNow SDK.
      • Push to or install an application on the authenticated instance from your local environment.
    • Automated Test Framework (ATF)
      • Tests can be generated by Build Agent and executed in ServiceNow Studio or ServiceNow IDE to confirm functionality after changes.
      • For more information on ATF, see Automated Test Framework (ATF).