In traditional development, you must manually translate business concepts into database schemas, APIs, and UI components. The C3 Agentic AI Platform combines two complementary architectural paradigms in order to simplify these requirements while remaining performant: Model-Driven Architecture (MDA) and Event-Driven Architecture (EDA).

​
The dual architecture paradigm

The diagram below illustrates how the C3 Agentic AI Platform separates domain modeling from system operations. C3 Architecture Diagrams This architecture creates a powerful separation of concerns:

Model-Driven Architecture

Define domain entities and their relationships. The platform automatically generates database schemas, APIs, and UI components from JSON-defined types.

Event-Driven Architecture

Handle data flows and processing through event-based interactions. Creates efficient, scalable systems for processing massive data volumes.
This dual approach separates “what” the system should do (domain logic) from “how” it should do it (system operations).

​
Model-driven architecture: The developer’s primary interface

MDAs are used when enterprises need to scale complex systems without getting lost in low-level implementation details. They allow developers to define concepts like “Customer” or “Sensor” as structured models, and the platform expands those definitions into database tables, API endpoints, and data access methods. In the C3 Agentic AI Platform, this means you can make a single declaration of a C3 Type that generates the underlying system operations needed to store, retrieve, and interact with its associated data.

The C3 Type System

Define domain entities with properties and relationships. The platform automatically generates database schemas, APIs, and UI bindings.

The Canonical Workbook

Discover pre-defined Types available in the C3 Agentic AI Platform.

​
Event-driven architecture: The system interaction layer

EDAs address the challenge of processing massive data volumes in enterprise systems by replacing constant polling with a publish-subscribe model. When important changes occur, they trigger events that flow through the system for efficient processing. The C3 Agentic AI Platform leverages this architecture to handle industrial-scale data from thousands of sources while maintaining performance and responsiveness across complex AI applications. The diagram below shows the basic flow of events through a system. When something important happens, it generates an event that multiple components can process independently. Event Flow Basics The C3 Agentic AI Platform’s event-driven approach transforms how data flows through the system:

Event Production

Systems generate events when meaningful changes occur. Events carry both data and metadata about the occurrence.

Event Consumption

Multiple consumers process events independently. Each consumer extracts value without affecting other systems.
For instance, in a manufacturing context, when a quality sensor detects an unexpected change, this single event triggers multiple parallel processes.
  • The digital twin updates the product’s virtual state
  • The analytics system adds the reading to historical data
  • And the anomaly detection system flags the unusual reading.
  • If a potential issue is identified, the alerting system notifies the quality control team.
The diagram below illustrates how events can be distributed to multiple consumers: Event Distribution Pattern This multi-consumer pattern enables diverse applications to derive value from the same data without interfering with each other, creating a more resilient and evolvable system.

​
Design patterns: Critical knowledge for C3 AI development

Understanding design patterns in the C3 Agentic AI Platform helps when modeling data, extending functionality, or troubleshooting complex interactions. These patterns are built into the platform and shape how applications are developed and behave.

​
Factory patterns and type-based development

What it is: The Factory pattern creates objects without specifying their concrete classes. A factory method returns objects through a common interface, hiding implementation details from the client code. How C3 AI implements it: The C3 AI Type System generates factory methods automatically when you define a Type. These methods handle creation, validation, and persistence of Type instances. The diagram below shows how the Type System creates and manages domain objects: For example, when you call WindTurbine.make() or WindTurbine.fetch(), you’re using factory methods that:
  1. Create the appropriate concrete implementation of the WindTurbine Type
  2. Handle validation of properties based on the Type definition
  3. Manage persistence to the appropriate storage system
  4. Return a consistent interface to work with the WindTurbine object
This is analogous to calling dialog.createButton() in the traditional Factory pattern, where you get back a Button object without needing to know its concrete implementation. Why it matters: Understanding the Factory pattern in C3 AI helps you:
  • Work with the Type System’s object creation mechanisms effectively
  • Understand how the platform instantiates different implementations based on Type definitions
  • Leverage the platform’s built-in factory methods for creating and retrieving objects
The Factory pattern itself doesn’t dictate your Type design decisions, but understanding how it’s implemented helps you work more effectively with the Type System.

​
Observer patterns and event-driven interactions

What it is: The Observer pattern notifies multiple objects when another object changes state. It enables distributed event handling without tight coupling between components. How C3 AI implements it: The C3 Agentic AI Platform uses an event processing system where producers publish events and consumers subscribe to them. When events occur, all subscribers are notified automatically. The diagram below shows how components subscribe to relevant events: For example, when a sensor reading is received, the C3 Agentic AI Platform can automatically:
  1. Update the digital twin’s state
  2. Trigger anomaly detection algorithms
  3. Update dashboards and visualizations
  4. Log the data for historical analysis
All of these actions happen independently and in parallel, without the components needing to know about each other. Why it matters: When designing event-driven components, understanding the Observer pattern helps you:
  • Structure event producers and consumers effectively
  • Decide when to use direct vs. indirect event handling
  • Manage dependencies between components
  • Design scalable, loosely-coupled systems
The C3 Agentic AI Platform implements this pattern through its CloudMessageSourceCollection and event handling mechanisms. 
// Example of implementing an observer in C3 AI:
type SourceOrdersInboundQueue mixes CloudInboundMessage<SourceOrdersJSON> {
  process: ~ js-server {
    // This method is automatically called when events arrive
    // Understanding the Observer pattern helps you design this processing logic
  }
}

​
Composite patterns and hierarchical data modeling

What it is: The Composite pattern treats individual objects and groups of objects uniformly. It organizes objects into tree structures where individual elements and compositions share the same interface. How C3 AI implements it: The C3 Agentic AI Platform supports hierarchical data modeling through parent-child relationships between Types. You can apply the same operations to individual objects or entire hierarchies. The diagram below shows how assets form hierarchical structures: For example, you can:
  1. Calculate the total energy production for a single turbine
  2. Use the same method to calculate production for an entire wind farm
  3. Apply the same approach to calculate production across all facilities in an enterprise
  4. The platform automatically handles the aggregation at each level
This uniform treatment of individual objects and compositions simplifies code and makes operations more consistent across different levels of the hierarchy. Why it matters: When working with hierarchical data structures, understanding the Composite pattern helps you:
  • Design Types that work at different levels of abstraction
  • Decide when to implement operations at the leaf level vs. the container level
  • Handle aggregation and inheritance in complex hierarchies
  • Create consistent interfaces across different levels of your domain model
The Composite pattern is useful for organizing systems with natural hierarchies, like industrial assets or company structures. It ensures the same operations work at different levels, allows tasks like maintenance to apply to both individual parts and the whole system, and makes it easy to add up data, like tracking total energy production from individual turbines to an entire enterprise.

​
Putting it all together

The C3 Agentic AI Platform’s architecture directly impacts how you build applications:
  • Model-Driven Architecture lets you focus on your domain, not implementation details. You define a wind turbine once, and the platform generates all the database schemas, APIs, and UI components.
  • Event-Driven Architecture handles data flows efficiently. When a sensor reading arrives, multiple systems can process it independently without tight coupling.
  • Design patterns bridge these architectures. The Factory pattern creates objects from your models, the Observer pattern enables event processing, and the Composite pattern lets you work with hierarchies uniformly.
Together, these concepts create a development experience where you:
  • Write less code with fewer bugs
  • Process data at scale without complex infrastructure
  • Build applications that evolve gracefully over time

Component Relationships

Learn more about how components relate to each other within the C3 Agentic AI Platform.

Reliability Example

See a practical example of the C3 Agentic AI Platform architecture in action.

Platform Overview

Return to the C3 Agentic AI Platform overview.