CLIODOT SURFACE
Give your software one programmable surface.
Bring connector actions, workflows, remote capabilities and internal services into one application-facing interface.
Define each capability once.
Then expose it through SDKs, REST, MCP, GraphQL, WebSockets or future interfaces without rebuilding the underlying implementation.
See Surface within Cliodot Appsawait cliodot.billing.customers.create({ email: "user@example.com" });A BROADER PUBLISHING MODEL
Your system is more than a collection of endpoints.
Traditional gateways focus on routing API requests.
Surface focuses on the capabilities your software makes available.
A Surface can contain:
Connector actions Workflows Remote capabilities Internal APIs Custom functions AI operations Database actions Organization-specific services
Those capabilities can then be projected into the interfaces your consumers need.
Surface is not limited by a single protocol.
It is the programmable boundary of your product.
COMPOSE YOUR SURFACE
Attach what your product can do.
Start by selecting a source.
Connector action
Expose an action from Stripe, Zoho, Paystack, Slack, Google, a database connector or any custom connector.
Workflow
Publish a multi-step business process as one clean capability.
Remote capability
Use a capability securely provided by another Cliodot organization.
Internal service
Connect an existing company API or service without exposing its internal implementation.
Custom function
Add domain-specific execution logic as part of the Surface.
The source remains private.
The public capability gets its own name, contract, permissions and version.
YOUR PRODUCT. YOUR LANGUAGE.
Expose business capabilities, not provider complexity.
An underlying Stripe connector action does not have to appear as Stripe in your SDK.
Internally, the capability may use Stripe.
Publicly, your developers can call:
await cliodot.billing.customers.create({
email: "customer@example.com",
});Instead of:
await cliodot.stripe.createCustomer({
email: "customer@example.com",
});Surface allows the publisher to define:
Capability name Namespace SDK method Input schema Output schema Required permissions Version Invocation mode Exposure methods Error contract
Your consumers interact with your product model, not the structure of the provider behind it.
EXPOSE ONCE. CONSUME ANYWHERE.
Project the same capability into every interface. SDK
Generate a natural, typed developer interface with autocomplete and documentation.
await cliodot.billing.customers.create({
email: "customer@example.com",
});
RESTExpose a secure HTTP endpoint.
POST /billing/customers
MCPMake the capability available as a tool that compatible AI systems can discover and invoke.
GraphQL
Publish the capability as a query, mutation or subscription.
WebSocket
Support persistent, real-time capability interactions and event streams.
The execution source remains the same.
Only the exposure changes.
GENERATED DEVELOPER EXPERIENCE
One SDK. Every capability on your Surface.
Cliodot generates SDK definitions from the Surface contract.
As capabilities are published, the generated client understands:
Available namespaces Methods Required fields Optional fields Input types Output types Error types Permission requirements Capability versions
When a developer types:
cliodot.their editor can suggest:
billing customers crm notifications reports
When they continue:
cliodot.billing.customers.create({the SDK can suggest the exact accepted fields.
The experience feels manually designed, but it is generated from the Surface definition.
STABLE CONTRACTS
Keep provider complexity behind the Surface.
Connector inputs are often provider-specific.
Connector responses are frequently larger and less stable than applications need.
Surface allows publishers to create a controlled boundary.
Input mapping
Rename fields, apply defaults, inject environment values, hide internal configuration and map clean public inputs into provider-specific requests.
Output mapping
Return only the information consumers need, normalize provider responses and preserve the public contract when the underlying service changes.
Your application can keep calling:
cliodot.billing.customers.create()even when the internal provider or workflow is replaced.
CONTROL AT THE CAPABILITY LEVEL
Exposure does not mean unrestricted access.
Every Surface invocation passes through a consistent runtime layer.
Cliodot can:
Authenticate the caller Resolve the Surface Resolve the capability version Authorize the requested action Validate the input Apply mappings and defaults Execute the underlying source Transform the response Record logs and traces Meter usage Enforce quotas and rate limits Return a consistent result
Permissions remain attached to the capability regardless of how it is exposed.
MORE THAN REQUEST AND RESPONSE
Choose the interaction model that fits the operation.
Surface capabilities may operate as:
Request and response
Perform an action and return a result immediately.
Async operation
Start long-running work and allow the client to check or await completion.
Stream
Return incremental results, ideal for AI and large data operations.
Subscription
Receive continuous updates or events.
Pagination
Navigate large result sets through a standard SDK experience.
Fire and forget
Accept an operation without requiring the caller to wait for completion.
The generated interface adapts to the capability definition.
ONE PROGRAMMABLE BOUNDARY
Create the capability layer your ecosystem consumes.
Use Surface to:
Build a unified SDK around several providers Add integration capabilities to a SaaS product Give AI agents controlled access to company actions Publish internal services through a governed interface Create partner-facing capability packages Standardize access across multiple applications Replace provider-specific logic without changing public contracts
DEFINE YOUR SURFACE
Turn everything your system can do into a programmable product.
Attach your capabilities, design the public contract and expose them through the interfaces your consumers already use.