Build custom agents, custom clients, plugins, providers, and Codebolt-native applications on top of the same engine that powers the Editor, CLI, Cloud, and autonomous agents.
The SDK is the scalability layer of Codebolt. Use the Agent SDK and agent framework to control agent behavior, the Client SDK to build custom interfaces and integrate other applications, the Plugin SDK to extend the engine, and the Provider SDK to connect agent execution across platforms and environments.
Codebolt is not just an app with an API. It exposes the layers you need to create agents, build interfaces, extend runtime behavior, connect external systems, and scale execution.
Use codeboltjs to create custom agents with direct access to files, git, terminal, browser, LLMs, memory, tasks, dynamic panels, environments, evals, and engine APIs.
Build agents like you would with LangChain, Mastra, or other frameworks, but Codebolt-aware. Compose tools, workflows, processors, message modifiers, compaction, and execution control for agents tailored to your workflow.
Use the Client SDK to build custom web apps, internal tools, dashboards, vertical IDEs, mobile surfaces, or product integrations that talk to Codebolt over REST and WebSocket APIs.
Use the Plugin SDK to add backend capabilities, commands, routes, hooks, dynamic panels, provider integrations, marketplace packages, and app-specific runtime logic.
Create custom agent providers and execution bridges so Codebolt can chain agent connections across platforms, environments, remote servers, and specialized runtimes.
Combine SDK layers to create Codebolt-native applications: a custom app UI, plugin backend, custom agents, provider routing, and cloud or self-hosted execution on the same engine.
Codebolt lets teams build agents the way they build software: with code, modules, tools, workflows, and explicit control over the agent loop. The codeboltjs Agent SDK gives agents direct access to Codebolt engine capabilities, while the @codebolt/agent framework provides a higher-level interface for tools, workflows, reusable processor pieces, message modifiers, loop detection, and conversation compaction. Use it when a generic prompt is not enough and the agent needs to follow your product, team, or domain workflow.
The Editor and CLI are clients of the engine. With the Client SDK, your application can be one too. Build a custom UI, vertical workspace, internal operations console, product-specific dashboard, or integration from another application. The client layer can call Codebolt APIs, subscribe to real-time sockets, manage threads, tasks, jobs, agents, environments, memory, git, files, and application state.
Plugins let you add capabilities inside the Codebolt engine itself. A plugin can expose routes, connect to external APIs, register hooks, open dynamic panels, mediate application requests, push live events, add provider behavior, and serve as the backend for a Codebolt-native application. That means your product logic can live close to agents, memory, tasks, environments, and execution rather than in a disconnected service.
The provider layer lets Codebolt connect to execution sources beyond one local runtime. Build custom providers to bridge agent connections across platforms, environments, remote machines, cloud sandboxes, or specialized agent systems. This is how the SDK story becomes a scaling story: agent work can move through the right provider instead of being trapped inside one client or one machine.
The real power appears when the SDK layers are used together. Use the Agent SDK to control the agent flow, the Plugin SDK to provide backend application logic, the Client SDK to create the interface, and the Provider SDK to route execution across environments. The result is a Codebolt-native application: software that uses the Codebolt engine as its backend instead of rebuilding agents, plugins, memory, tasks, orchestration, and scaling from scratch.
Use SDKs when you need something more specific than a stock editor, one terminal session, or one hosted agent.
Create agents for code review, migration, compliance, support, research, release management, data labeling, product planning, or any domain workflow.
Build your own UI on top of Codebolt: dashboards, vertical IDEs, internal portals, mobile apps, customer-facing tools, or embedded product surfaces.
Add integrations, routes, panels, hooks, commands, marketplace packages, backend logic, and domain capabilities directly into the engine runtime.
Route agent work to local runtimes, cloud sandboxes, remote servers, or third-party agent platforms using custom providers.
Package Codebolt into your own application or make Codebolt itself become the shell for your app through panels, plugins, and custom clients.
Grow from one custom agent to multi-agent, multi-environment workflows without changing the foundation.
Let you use their agent, but not build your own agent runtime around your workflow
Expose a fixed UI instead of a client SDK for custom applications
Treat plugins as add-ons instead of runtime backends
Do not provide a provider layer for chaining execution across platforms
Force teams to rebuild memory, tasks, jobs, orchestration, and scaling around the tool
Agent SDK and framework let you control agent flow, tools, processors, workflows, and compaction
Client SDK lets you build custom interfaces and integrate Codebolt into other applications
Plugin SDK lets you extend the engine and run app backend logic inside the runtime
Provider SDK lets you bridge agent execution across environments and platforms
Together, the SDK layers let teams build Codebolt-native applications that scale with the engine