Skip to main content

Custom Agentic Applications

Custom agentic applications are product-specific applications built on top of the Codebolt server. Instead of using the stock desktop or web UI, you create your own interface and workflow shell, while Codebolt still provides the agent runtime underneath.

This section is about applications that combine:

  • a custom front-end or workflow shell
  • direct server access or a plugin bridge
  • Codebolt agents, tools, threads, and memory as the execution backend

That is different from:

  • Custom Interfaces, which explains the client-side connection model in general
  • Plugins, which explains plugin lifecycle and runtime APIs

This section explains how those pieces come together into an actual application.

Custom agentic application architecture showing a custom UI shell, an optional plugin backend, and the Codebolt server as the shared runtime.Three Ways To Build A Custom Agentic Application1. Standalone AppYour front-end talks straight to the Codebolt server over HTTP APIs and sockets.Example`packages/simpleui`React SPA + axios `/api` + Socket.IO namespaces2. UI Wrapped By A PluginA plugin serves the UI inside Codebolt. The UI can still remain mostly front-end only.Example`sample-plugins/simpleui-plugin`plugin manifest points `ui.path` at the built SPA3. Plugin-Backed UIThe UI talks to a plugin bridge, and the plugin acts as the application backend.Example`sample-plugins/feedback-form-plugin``codeboltPlugin` bridge + `plugin.dynamicPanel.*`Codebolt Server Is Still The Runtime Of RecordYour application changes the UX and orchestration shape, but the server still owns files,tasks, threads, chat, agents, tools, memory, and real-time execution state.HTTP APIsrequests, CRUD, commandsSockets / Eventslive chat, tasks, swarm, logsPlugin Busdynamic panel, plugin sdk, gatewaysdirect APIs + socketsplugin hosts the application shelliframe bridge + plugin backendPick the lightest shape that matches your product: direct client if the UI can talk to the server,plugin wrapper if you want it embedded in Codebolt, plugin-backed bridge if the UI needs backend logic or mediation.

The Core Idea​

A custom agentic application is not just "a UI that can chat". It is an application where the UX, workflow, and business context are yours, while Codebolt remains the execution engine for:

  • agent runs
  • threads and conversation state
  • tools and MCP access
  • memory and event history
  • jobs, tasks, and background execution

In practice, that means your app is usually one of three shapes:

  1. a standalone front-end that talks directly to the server
  2. a UI that is packaged and hosted by a plugin
  3. a plugin-backed UI where the plugin acts as the backend bridge for the interface

In the plugin-backed shape, there are two valid communication patterns over the panel bridge:

  • request/response:
    • UI: codeboltPlugin.fetch('/path', { method, json })
    • plugin: plugin.dynamicPanel.router(panelId).post('/path', handler)
  • async/event messaging:
    • UI: codeboltPlugin.sendMessage(...) and codeboltPlugin.onMessage(...)
    • plugin: plugin.dynamicPanel.send(...) and plugin.dynamicPanel.onMessage(...)

Use the request/response model for app-like actions such as forms, saves, and commands. Use the async/event model for streaming, live updates, multi-turn exchanges, and custom protocols.

Real Examples In The Codebase​

This documentation is based on three concrete examples:

  • packages/simpleui — a standalone React application that calls server APIs and subscribes to sockets directly
  • sample-plugins/simpleui-plugin — a plugin that wraps and serves the built Simple UI as a plugin UI
  • sample-plugins/feedback-form-plugin — a minimal example where the plugin is the backend for the UI and the UI talks through the injected codeboltPlugin bridge

Page Guide​

See Also​