The C3 Front-End Architecture
On C3 you build an ordinary React front end, and the C3 Agentic AI Platform owns a fixed spine beneath it. That spine is the data, the typed API, authentication, serving, and the design tokens. You build the interface with standard React, and you make a small, specific set of considerations to connect that interface to the spine. This page names what the C3 Agentic AI Platform handles and the consideration each one leaves you, and links to the page that covers it in depth.
What the C3 Agentic AI Platform handles
The C3 Agentic AI Platform provides the data as a Type system, exposes every Type and method at POST /api/8/{Type}/{action}, authenticates requests, serves your built bundle from ui/content, and carries the design tokens for the C3 look. Because it owns that spine, the front end holds no backend, no login flow, no hosting, and no release pipeline of its own. What remains for you is the interface and the considerations below.
| The C3 Agentic AI Platform handles | The consideration you make |
|---|---|
The data model as a Type system, callable at POST /api/8/{Type}/{action} | How you shape and scope each request, and what you push to the server |
Authentication, automatic through the c3auth cookie when it serves the application | The token transport, only when the front end is hosted somewhere other than the C3 Agentic AI Platform |
Serving your static bundle at /<env>/<app>/, one bundle in any environment | The relative build base, single-page-application serving, and the routing style |
| Deploying your built content to an environment | A single-node or shared environment, and the compute the application runs on |
| The design tokens for the C3 look | Mapping the tokens into your component library and its charts |
Everything not in this table is ordinary React that you own and build as you always have. The sections below expand each consideration.
Reaching the backend
The C3 Agentic AI Platform generates the API from the data model, so every Type and every method it declares is reachable at POST /api/8/{Type}/{action} the moment the Type exists, with no controller, route, or serializer to write. You address it with a relative URL whose base comes from the c3AppUrlPrefix cookie, so one build reaches the right environment with no configuration.
Your consideration is the request itself. You shape a read with a FetchSpec, which is the filter, the projection, the order, and the paging, you traverse a relationship by its reference id, and you push counting and aggregation to the server with fetchCount and evaluate rather than pulling rows to the browser to measure or summarize them. Make API Requests teaches the call and its query language.
Authenticating requests
When the C3 Agentic AI Platform serves the application, authentication is automatic and you write none of it. Identity is delegated to the cluster identity provider over OpenID Connect (OIDC) or Security Assertion Markup Language (SAML), and the signed session token rides in an HttpOnly c3auth cookie the browser sends on every same-origin request, paired with a c3csrf cookie that closes cross-site request forgery.
Your consideration arises only when the front end is hosted somewhere other than the C3 Agentic AI Platform, that is, served to the browser from a different origin. Then you carry the same token in a header and decide which transport it uses, and you handle the CORS boundary that governs cookie-based cross-origin calls. Authenticate Requests covers the transports and that boundary.
Serving and environment portability
The C3 Agentic AI Platform's UiService serves your static bundle at https://<cluster>/<env>/<app>/, secured and scaled with the environment, and one built bundle runs in any environment because the application resolves its API base from the c3AppUrlPrefix cookie rather than a hardcoded host. You never rebuild or reconfigure the front end to promote it from development to production.
Your consideration is at build time. You set a relative base so assets resolve under the path prefix, enable single-page-application serving so clean routes work, and choose path or hash routing. Bundle and Serve covers these.
Build and deployment
You build the bundle into ui/content, and the C3 Agentic AI Platform serves it from there. Your consideration is where the application runs: a single-node environment, deployed from the C3 AI VS Code extension while you develop, or a shared environment, promoted through C3 Studio and Release Management as a versioned artifact, along with the compute the application uses. Deploy to an Environment covers both paths.
Styling
The C3 Agentic AI Platform carries the design tokens that give the application the C3 look: the colors, typography, spacing, and chart palette. Your consideration is binding those tokens into your component library's theme and its charts, so the application matches the rest of the suite.
The sanctioned design-token package is still being finalized, so until it ships you reproduce the token values rather than depend on the styling packages. Style with the C3 Design System covers the current approach.
What stays yours
Everything the C3 Agentic AI Platform does not own is ordinary React, and it is most of the front end. You own the components, the pages, the routing, the state, and the styling logic, and you build them with the React libraries you choose. The boundary is deliberate, so the front end carries no framework lock-in and runs unchanged, while the C3 Agentic AI Platform owns the spine every enterprise application needs.
For the parts you own, the intended default toolkit is shadcn/ui for components, ECharts for charts, and TanStack Table for data grids, and you may use any React library instead.
The toolkit recommendation is a product decision that is still being finalized, so treat it as the intended default and expect it to be confirmed.
How you reuse
Reuse is a consideration the C3 model reshapes. You reuse code by importing shared components as ordinary npm libraries, and you reuse a whole application by forking a template and owning the copy. You do not reuse by depending on an already-compiled application and injecting or rearranging its pages. That was the model of SDL, the declarative UI framework that the C3 Agentic AI Platform is retiring. Because the front end only calls /api/8/{Type}/..., which package owns a given Type is a packaging concern rather than a front-end one, so needing another package's data never requires reaching across applications in the interface layer.