---
sourceDocument: Australia Build or modify applications
sourceDocumentLink: https://www.servicenow.com/docs/r/australia/application-development

 Release :

    - australia

ft:locale :

    - en-US

ft:publication_title :

    - Australia Build or modify applications

ft:clusterId :

    - cadev

bundleId :

    - cadev

workflow :

    - Development, Data, and Analytics


---

# Deploying Build Agent work

# Deploying what you built with Build Agent {#ariaid-title1}

Release version: Australia  
Updated September 22, 2026  
![](https://www.servicenow.com/docs/portal-asset/ico-clock) 4 minutes to read
Summarize  
![AI sparkle icon](https://servicenow.com/docs/portal-asset/ai-sparkle-icon) 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 guide explains how to deploy applications created with Build Agent in ServiceNow, outlining workflows, deployment methods, and tools to move apps from development through testing to production.
It helps ServiceNow customers understand how to manage application lifecycle transitions securely and efficiently, ensuring collaboration, quality checks, and compliance throughout the process.
Show full answer Show less  

## Deployment Workflow

* **Collaborative design:** Business and IT teams define requirements using preferred tools.
* **AI-driven development:** Build Agent, Autonomous Engineer, and ServiceNow Otto generate app updates from files, chat, and diagrams.
* **Review and testing:** Teams preview, revise, and run performance and readiness tests.
* **Developer review:** Developers validate AI-generated changes and confirm readiness.
* **Deployment approval:** Deployment managers initiate approval processes.
* **Autonomous checks:** AI agents scan and remediate issues before deployment.
* **Final deployment:** Apps are securely deployed after all approvals and checks.

**Important:** Changes remain isolated until explicitly deployed, allowing iteration without affecting live applications. Isolation is managed differently in ServiceNow IDE (using source/build artifacts) and ServiceNow Studio (using update sets).

## Deployment Methods

* **Git-based source control integration:** Supports pushing scoped apps to Git repositories (e.g., GitHub, Bitbucket) for branching, merging, and automated CI/CD deployments. Requires Australia Patch 5 for Studio source control use.
* **Update sets and application packaging:** Tracks changes with System Update Sets and packages them into scoped applications using Application Repository (AppRepo) for easier transport and installation.

## Options for Moving Apps Between Instances

* Wrap entire scoped applications in update sets and promote via deployment requests or standard update set processes.
* Publish apps to AppRepo for distribution and use with ReleaseOps pipelines, which support automated testing and deployment approvals.
* Directly push Git-connected app changes from the Build Agent chat panel to remote repositories.

## Additional Deployment Tools

* **App Engine Management Center (AEMC):** Conducts governance checks (ACLs, roles, compliance) and monitors deployments with dashboards. Integrates with ReleaseOps pipelines.
* **ReleaseOps:** Automates multi-instance deployments with customizable playbooks, including update set validation, Automated Test Framework (ATF) execution, approval gates, and scheduling.
* **ServiceNow SDK:** Enables offline app movement between local environments and instances, supporting integration with external CI/CD workflows.
* **Automated Test Framework (ATF):** Generates and executes tests to validate app functionality post-changes, integrable with Studio and IDE.

## Important Considerations

Deployment paths using Application Repository and update sets are mutually exclusive for a given application on an instance---once you deploy using one method, you cannot switch to the other for that application on the same instance.

Global applications can be included in both Application Repository and source control deployments.  
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 {#build-agent-deployment__section_tdt_kdb_2jc}

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, Autonomous Engineer and ServiceNow Otto 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.
{#build-agent-deployment__ol_a3z_nch_phc}  
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.
{#build-agent-deployment__ul_deploy_isolation}

## Deployment methods for Build Agent {#build-agent-deployment__section_n5z_ldb_2jc}

Build Agent and Autonomous Engineer support the following deployment methods for apps created and edited with agentic development:

* Git-based source control integration: 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 supports bring-your-own Git integration, such as GitHub or Bitbucket.
  * You must be on Australia Patch 5 to use source control in ServiceNow Studio.
  * For more information, see [Integrating source control with the ServiceNow IDE](https://www.servicenow.com/docs/2nOvcaJHYcyPhyWtYVv_lg "Integrate with remote Git repositories to manage applications in source control with the ServiceNow IDE.") and [Fluent source control in ServiceNow Studio](https://www.servicenow.com/docs/olSzCoafs_2yv2IK6vEnxA "Connect to remote Git repositories to track and manage Fluent applications in ServiceNow Studio.").
  {#build-agent-deployment__ul_mpd_rch_phc}
* 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 information on update sets for Build Agent, see [Update sets and Build Agent](https://www.servicenow.com/docs/25K10uRGfz2uc5gvqIreEA "When you work with Build Agent, your changes are automatically tracked in update sets so you can review, revert, and deploy them without leaving ServiceNow Studio.").
  * For information on update sets for Autonomous Engineer, see [Update sets and Autonomous Engineer](https://www.servicenow.com/docs/WIzQlyQPnJtD4reybyhvuQ "When you work with Autonomous Engineer, your changes are automatically tracked in update sets so you can review, revert, and deploy them without leaving ServiceNow Studio.").
  * For more information on System Update Sets, see System update sets.
  {#build-agent-deployment__ul_phq_qf5_yhc}
{#build-agent-deployment__ol_bmr_ff5_yhc}

## Options for moving apps through instances {#build-agent-deployment__section_zw3_mdb_2jc}

After you create an app using Build Agent or Autonomous Engineer, 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.
   {#build-agent-deployment__ol_wjc_vp5_yhc}
2. Publish the app to AppRepo:
   * You can use a Git-based process or update sets to publish to AppRepo.
   * Scoped apps and 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](https://www.servicenow.com/docs/S~qkI6Li8JtSw_8B8LsNHA "After you develop and test a custom application, you can make the application available to company instances by publishing it to the ServiceNow application repository.").
   {#build-agent-deployment__ul_npd_rch_phc}
{#build-agent-deployment__ol_y4b_2g5_yhc}

If your app is connected to Git-based source control, you can also push changes to a remote repository directly from the Build Agent chat panel. For more information, see .

## Additional deployment tools {#build-agent-deployment__section_fbs_mdb_2jc}

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](https://www.servicenow.com/docs/olYijlu~xqHfISUgxYVNoQ "Track and manage your requests, deployments, applications, and collaborative developers using the App Engine Management Center (AEMC) in your production instance. Additionally, AEMC allows admins to manage app development from intake through production.").
  {#build-agent-deployment__ul_m4n_pq5_yhc}
* 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](https://www.servicenow.com/docs/OGg~z86Jvh8RrLkeCibsBA "ReleaseOps automates deployment of changes across your pipeline, increases predictability and reliability of deployments, and reduces the risk of releasing changes to production.").
  {#build-agent-deployment__ul_zpy_gdh_phc}
* 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.
  {#build-agent-deployment__ul_mwp_w3g_k3c}
* 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)](https://www.servicenow.com/docs/4hkh6VNi_eAnyfY91R522Q "The Automated Test Framework (ATF) enables you to create and run automated tests to confirm that your instance works after making a change. For example, after an upgrade, during application development, or when deploying instance configurations with update sets. Review failed test results to identify the changes that caused the failure and the changes that you should review.").
  {#build-agent-deployment__ul_ppd_rch_phc}
{#build-agent-deployment__ul_mwj_rch_phc}

## Mixing application repository and update set deployment {#build-agent-deployment__section_app-repo-update-set-exclusion}

For any given application on a given instance, the application repository deployment path and the update set deployment path are mutually exclusive. After you deploy an application to an instance using the application repository, you can't switch to update sets for that application on that instance, and the reverse is also true.  
Note:  
You can include global apps in the Application Repository and source control.
For more information, see the [Can't mix Update Set and App Repo deployment for the same application \[KB0715422\]](https://support.servicenow.com/kb?id=kb_article_view&sysparm_article=KB0715422) article in the Knowledge Base.

