A package in the C3 AI Agentic Platform is a way to bundle code so other applications can use it. In a maintenance context, packages could include data models for assets and sensors, logic for condition monitoring, and dashboards for tracking equipment health. Applications can be built from combining several packages or they can be built from a single package. The rest of this section will explain how to make the right choices for your application. What you need to know about packages:
  • You develop packages locally, publish them as versioned artifacts, and then other applications can import them.
  • Each package needs a manifest file to identify it, and can include source code, tests, configuration, and other resources.
  • Package structure in C3 AI is flexible, but there are conventions that help you organize your project by triggering built-in automations.

​
Understanding packages

​
Package structure

C3 AI packages use directory structure to activate platform features. Each directory serves a specific purpose, triggering different automations when files are placed in the correct locations. A typical package includes these directories: 
reliabilityMonitor/
  src/                        # Application logic
  config/                     # Environment config
  metadata/                   # Platform integration
  seed/                       # Initial data
  data/                       # Reference data
  ui/c3/meta/                 # Frontend code
  test/                       # Tests
Each directory enables specific platform features:
  • src/: Core application logic with Type definitions and implementations
  • ui/c3/meta/: Frontend components and pages
  • config/: Environment-specific settings
  • metadata/: Platform integration points
  • seed/: Initial data loaded during first deployment
  • data/: Static reference data and lookup tables
  • test/: Automated tests that mirror your source structure
For detailed information about each directory and how to structure your files, see the Creating a Package guide.

​
Package examples

In a maintenance context, a wind farm application might use two packages:
  • An Equipment Monitoring package containing turbine models, failure prediction, and alert dashboards
  • A Performance Analytics package containing efficiency calculations and trend visualizations
Here’s how these packages would be structured: The Equipment Monitoring package includes everything needed for real-time monitoring: types for representing turbines and sensors, methods for predicting failures and handling alerts, and a dashboard UI for operators. The Performance Analytics package focuses on efficiency tracking with its own types for metrics, methods for trend analysis, and visualization components. These feature sets can then be reused in other applications, like a Solar Farm or Battery Storage system that needs similar monitoring and analytics capabilities.

​
Package lifecycle

Packages need to be created and published to be reused. Let’s follow our Wind Farm application’s packages through this process:

​
Create

You start by creating packages within your application, each focused on a specific business capability. In our Wind Farm example, we have packages for monitoring equipment health and analyzing performance:

​
Publish

Once your packages are ready for sharing, you publish them as artifacts. An artifact is a versioned snapshot of your package that includes all its code, configuration, and resources. This versioning ensures other applications can depend on specific, stable versions of your packages:

​
Reuse

Published artifacts become available to other applications in your organization. For example, a Solar Farm application might need the same equipment monitoring and performance analysis capabilities. Instead of building these features from scratch, it can import the existing artifacts: This lifecycle enables you to build a library of reusable features across your organization. As you develop new applications, you can combine existing packages in different ways to quickly implement common functionality while focusing your development efforts on unique requirements.
Artifacts only become available to you once they’re published to the C3 AI Agentic Platform and you have the necessary permissions to import them.

​
Next steps

Now that you understand the basic concepts of packages in the C3 AI Agentic Platform, the following pages will explain certain concepts in greater detail:

Creating a Package

Learn about each folder’s purpose in detail, with examples of files and their contents. This guide will help you structure your package effectively.

Importing Packages

Understand how to reuse components across packages, manage dependencies, and handle versioning to build modular applications.

Artifact Management

Follow our comprehensive guide on deploying applications, managing releases, and making your packages available across environments.

Package Tools

Discover the suite of tools C3 AI provides for managing package releases, automating deployments, and maintaining package dependencies.