Introduction
Pega Infinity 26 represents a major evolution of the Pega Platform, combining its established case-management, workflow, decisioning, and data capabilities with an increasingly AI-native architecture. Pega announced general availability of Infinity 26 in July 2026, highlighting governed agentic AI, predictable AI execution and costs, and an AI-native development experience as major areas of the release.
Understanding the internal architecture of Infinity 26 is important because modern Pega applications are no longer simply server-rendered workflow applications. The platform increasingly operates as a combination of a powerful server-side orchestration and business-processing layer, API-driven digital experiences, client-side UI orchestration, data services, and governed AI capabilities.
At a high level, the architecture can be understood as:
User Experience → Client Orchestration → DX APIs → Infinity Platform → Data, Rules, Workflow, Integrations, and AI
This architecture allows organizations to build applications that are scalable, reusable, API-driven, and capable of incorporating AI into mission-critical business processes.
What Is Pega Infinity 26?
Pega Infinity 26 is the latest major generation of the Pega Infinity platform. Its architecture builds on Pega’s enterprise application platform while adding stronger AI and agentic capabilities.
The release focuses on areas including:
- Enterprise application development
- Workflow orchestration
- Customer engagement
- AI-powered automation
- Agentic workflows
- Governed AI execution
- Modern user experiences
- API-driven application development
- Enterprise scalability
Pega describes Infinity 26 as a platform for scaling AI while maintaining governance, predictable outcomes, and predictable costs.
The Infinity Platform as the Core
The Infinity Platform remains the central processing layer.
It provides capabilities for:
- Case management
- Workflow processing
- Business rules
- Data management
- Decisioning
- Integrations
- Security
- AI orchestration
In the Constellation architecture, the Infinity server remains responsible for core business processing while the client handles significant portions of UI orchestration and rendering. Pega describes the Infinity server as the layer containing business rules, logic, and data, with DX APIs connecting it to the client experience.
The Client-Side Architecture
One of the biggest architectural changes introduced by Constellation is the increased responsibility of the client device.
In the traditional architecture, the server performed much of the UI rendering work.
In Constellation:
- The browser requests application information.
- DX APIs return data and UI metadata.
- The client-side orchestration engine interprets that information.
- Components are rendered in the browser.
- User interactions generate subsequent API requests.
This reduces the amount of UI rendering work performed by the server.
Constellation Architecture
Constellation is an important architectural layer in modern Pega applications.
It follows principles such as:
- API-first development
- Separation of concerns
- Model-driven UI
- Prescriptive design
- Client-side orchestration
- Configuration over customization
Pega describes Constellation as an API-first architecture using an MVC-style separation in which Pega Platform provides the model, the Constellation design system provides the view, and the orchestration layer connects them through DX APIs.
Constellation Design System
The Constellation design system provides reusable UI components and patterns.
Instead of building every UI element from scratch, developers configure application views using prescribed components.
Examples include:
- Text fields
- Dropdowns
- Tables
- Buttons
- Date controls
- Forms
- Views
- Widgets
This configuration-driven approach reduces the amount of custom UI code that developers need to maintain.
Pega’s architecture emphasizes moving from customization toward configuration, with the data model and application configuration driving much of the resulting experience.
Constellation DX API Layer
The DX API acts as the communication layer between the frontend and Pega Platform.
The Constellation DX API is a set of model-driven REST endpoints that can be used to view, create, and update cases and assignments. It also powers Pega’s native Constellation experiences and can support custom frontend technologies.
The API layer provides:
- Case information
- Assignment information
- View metadata
- Actions
- Data
- Validation information
- Workflow operations
This means frontend applications do not need to reproduce Pega business logic.
Model-Driven API Processing
The Constellation DX API differs from the traditional DX API architecture.
The Constellation DX API is centered around View-based authoring rather than section-based authoring. Its responses separate data from view layout and provide metadata that can be interpreted by different frontend technologies.
View Metadata Processing
Constellation does not rely on traditional server-generated HTML for its modern UI architecture.
Instead, the server provides metadata describing the View.
Metadata can describe:
- Fields
- Layouts
- Actions
- Validation
- Conditional visibility
- Component information
- Data bindings
The client-side orchestration layer interprets this metadata and renders the UI.
Pega states that Constellation DX API responses contain the information needed to reproduce Views across frontend frameworks, including layouts, fields, validation, conditional visibility, and actions.
Case Processing Engine
Case processing remains a fundamental part of Infinity 26.
The Case Engine manages:
- Case creation
- Stages
- Processes
- Assignments
- Approvals
- Routing
- SLAs
- Case status
- Case relationships
The user interface is therefore only one layer of the overall architecture.
The business process remains centralized in the Pega Platform.
Each stage can involve business rules, data operations, integrations, and increasingly AI-powered capabilities.
Rule Processing Layer
Pega’s rule-driven architecture remains fundamental.
The platform resolves and executes rules for:
- Workflow
- Validation
- Decisioning
- Data transformation
- Security
- Integration
- UI behavior
This enables applications to centralize business logic rather than duplicating it across frontend channels.
Decisioning Architecture
Decisioning allows applications to make business decisions dynamically.
Examples include:
- Eligibility
- Customer segmentation
- Routing
- Pricing
- Next-best-action
- Risk evaluation
Decision logic can be incorporated directly into workflows and customer interactions.
Data Architecture
The data layer supports the information required by cases, workflows, decisions, and integrations.
It may involve:
- Application data
- Case data
- Reference data
- External data
- Data Pages
- Data Objects
- Database persistence
Efficient data access is essential for high-volume enterprise workloads.
Data Pages and Data Access
Data Pages provide a reusable abstraction for retrieving and managing data.
They can retrieve information from:
- Databases
- REST services
- SOAP services
- Other Pega applications
- External systems
Data Pages also provide caching and parameterization capabilities, helping applications avoid unnecessary repeated data retrieval.
Integration Layer
Infinity applications frequently communicate with external systems.
Common integration patterns include:
- REST APIs
- SOAP services
- Messaging
- Database connectivity
- Event-driven integrations
The integration layer allows Pega to coordinate processes across enterprise applications.
Security Architecture
Security operates across multiple layers.
Important areas include:
- Authentication
- Authorization
- Access Groups
- Roles
- Privileges
- Access Control Policies
- API security
- Data-level security
The architecture ensures that exposing business processes through APIs does not mean exposing unrestricted access to the underlying data.
AI Architecture in Infinity 26
One of the most important architectural developments in Infinity 26 is the deeper integration of AI and agentic capabilities.
Pega states that Infinity 26 enables enterprises to design, orchestrate, and govern AI agents across operations, customer service, and customer engagement workflows.
Predictable AI Architecture
Infinity 26 introduces Pega Predictable AI architecture.
According to Pega, this approach performs more AI reasoning at design time so runtime execution can be more token-efficient and predictable. Pega also describes an outcome-based pricing model rather than metered token charges.
Architecturally, this represents a shift toward:
- Design-time AI optimization
- Governed runtime execution
- Predictable AI behavior
- Reduced runtime reasoning overhead
- Enterprise-scale AI orchestration
Pega Infinity Studio
Infinity 26 also introduces Pega Infinity Studio, an AI-native development environment.
Pega describes Infinity Studio as combining coding agents with Pega’s application-development practices and AI capabilities to accelerate development while maintaining governance and enterprise standards.
This extends the architecture beyond runtime execution into the development lifecycle itself.
Event and Asynchronous Processing
Enterprise applications often need to process operations asynchronously.
Examples include:
- Notifications
- Background processing
- External integrations
- High-volume data processing
- AI tasks
Asynchronous architecture helps keep user-facing transactions responsive while long-running work continues independently.
Scalability Architecture
Enterprise applications must support large numbers of users, cases, transactions, and integrations.
Scalability depends on:
- Stateless request processing
- Efficient API design
- Database optimization
- Caching
- Asynchronous processing
- Horizontal infrastructure scaling
Constellation also reduces server-side UI workload by shifting orchestration and rendering responsibilities toward the client.
Performance Architecture
Modern Pega applications benefit from separating UI rendering from server-side business processing.
The browser performs more of the UI orchestration, while the server concentrates on:
- Business rules
- Case processing
- Data processing
- API services
- Workflow orchestration
Pega’s Constellation architecture documentation describes significantly smaller network payloads and fewer requests compared with traditional approaches, although actual application performance depends on implementation and workload.
Observability and Troubleshooting
Understanding the architecture also improves troubleshooting.
Developers can analyze different layers independently:
Frontend Layer
Check:
- Browser Network tab
- API requests
- JSON responses
- Client-side rendering
DX API Layer
Check:
- Request payload
- Response payload
- Authentication
- API errors
Pega Processing Layer
Check:
- Clipboard
- Tracer
- Rule execution
- Case processing
Database Layer
Check:
- SQL execution
- Query performance
- Indexes
- Locking
This layered approach makes troubleshooting more systematic.
Traditional Architecture vs Modern Infinity Architecture
| Area | Traditional Approach | Modern Constellation-Based Approach |
| UI rendering | Server-oriented | Client-oriented |
| UI structure | Sections | Views |
| Communication | Traditional UI processing | Model-driven DX APIs |
| Frontend | Tightly coupled | Decoupled |
| UI customization | High customization | Configuration-oriented |
| Rendering | Server-generated | Client-side orchestration |
| Business logic | Pega Platform | Pega Platform |
| API architecture | Traditional DX APIs | Constellation DX APIs |
| AI | Separate capabilities | Increasingly integrated into workflows |
The modern architecture does not remove the Infinity server; instead, it changes how responsibilities are distributed between server and client.
Key Architectural Principles
API First
Business capabilities are exposed through APIs rather than being tied to a particular UI.
Center-Out Architecture
Business logic remains centralized while multiple channels consume the same capabilities.
Separation of Concerns
UI, orchestration, business logic, and data responsibilities are separated.
Configuration Over Customization
Applications rely more heavily on prescribed components and configuration.
Governed AI
AI capabilities operate within enterprise policies and workflows.
Reusable Architecture
Business logic can support multiple channels and experiences.
Challenges for Architects
Infinity 26’s architecture introduces several areas that architects must consider.
Client-Side Complexity
More responsibility is placed on the client for orchestration and rendering.
API Design
Efficient API usage becomes increasingly important.
AI Governance
AI agents require appropriate security, authorization, monitoring, and governance.
Integration Complexity
Enterprise AI and workflow architectures may involve multiple internal and external services.
Performance Optimization
Architects must consider both client-side and server-side performance.
Best Practices for Infinity 26 Architecture
- Keep business logic centralized in the Pega Platform.
- Use Constellation Views instead of unnecessarily recreating legacy UI patterns.
- Use DX APIs for modern frontend integrations.
- Minimize custom frontend business logic.
- Reuse Data Pages and business rules appropriately.
- Design APIs with efficient payloads.
- Use asynchronous processing for long-running operations.
- Monitor both client and server performance.
- Apply strong authorization to API-driven applications.
- Govern AI agents as part of the enterprise workflow.
- Minimize unnecessary customization.
- Design applications for future platform upgrades.
Future Direction
The architecture of Pega Infinity is increasingly moving toward a model where:
Business Process + Data + Decisions + APIs + AI + User Experience
operate as coordinated components rather than isolated technologies.
Infinity 26 strengthens this direction through AI-native development, governed agentic workflows, and the continued evolution of the platform’s orchestration architecture.
This creates opportunities for applications that can:
- Understand business context
- Make governed decisions
- Orchestrate AI agents
- Automate repetitive work
- Involve humans when necessary
- Adapt processes dynamically
Conclusion
The Internal Architecture of Pega Infinity 26 is best understood as a layered enterprise platform in which the Infinity server remains responsible for business logic, case processing, data, workflow, decisions, and integrations, while modern Constellation applications move significant UI orchestration and rendering responsibilities to the client through model-driven DX APIs.
The architecture becomes even more significant with Infinity 26’s expanded AI capabilities. AI agents can participate in governed business workflows, while AI-native development capabilities are being integrated into the application development lifecycle.
For Pega developers and architects, understanding these architectural boundaries is critical. It helps explain how cases are processed, how Views are rendered, how DX APIs communicate with the platform, how business rules remain centralized, and how AI can be introduced without abandoning enterprise governance.
Ultimately, Infinity 26 represents a continued movement toward API-driven, client-orchestrated, configuration-focused, and AI-enabled enterprise application architecture, providing a foundation for scalable and adaptable mission-critical applications.
