Ductape
Beta
Ductape
Tour / Welcome
Ductape
Your agents can write the code. Give them a backend they can actually work with.
AI makes software faster to build. Every feature still depends on real payments, databases, messaging, storage, and APIs. Ductape makes those capabilities legible, composable, and executable. Define them once. You and your agents reuse them everywhere.
One shared backend for your team, your application, and your agents. Discover capabilities through MCP, configure them in the workbench, and execute them from code.
Backend and frontend packages for TypeScript, NestJS, JavaScript, React, and Vue. One surface for every component you configure.
Visual control plane for products, apps, environments, and resources. Cloud-hosted or deployed in your VPC, same UI and APIs.
Native workbench clients with the same experience as cloud, connect to cloud or your self-hosted instance.
Seed environments, export configs, and wire CI/CD without clicking through the UI.
Give agents a discoverable map of components, actions, and environments so they can build on what already exists and execute actions within their workspace access.
Where Ductape runs, and how you isolate config per stage.
Managed workbench, automatic updates, fast onboarding. Best when you want to ship in minutes without operating control plane infrastructure.
Run the workbench in your VPC or on-prem. You own networking, backups, and compliance boundaries, feature parity with cloud.
Create dev, staging, production (and more) on each product. Secrets, endpoints, and provider choices are per environment; the SDK resolves them at runtime, including secrets shared securely with partner workspaces when you collaborate.
Tour / Why Ductape
A payment provider can charge or refund. A database can update an order. But the knowledge of how they work lives across SDKs, env files, application code, and people. Agents have to reconstruct it. Teams re-implement it.
Every new feature has to rediscover the backend.
Defined capabilities, shared execution, visible results.
The bottleneck is making the backend legible enough to build on. Ductape turns its capabilities into components that carry their own context: configuration, credentials, environments, actions, failure handling, and observability.
Components define what your backend can do. Features compose those actions into business logic. The same payment, database, or messaging component can serve many features without rewiring the foundations.
Connect payments, databases, messaging, storage, and APIs. Define their actions and configure how they run in development, staging, and production. Your team and your agents build against the same capabilities.
Same components. Many features.
Features run through a shared runtime with retries, timeouts, error handling, logs, metrics, and tracing. See what exists, what uses it, and what happened when it ran. When something breaks, follow the execution path.
An API key is not context. Agents need to know which actions exist, which environment they target, what they expect, and how they fail.
As agents write more of the application, your team still has to operate it. Reusable components and shared execution visibility keep the backend understandable as the volume of code grows.
Checkout, refunds, and reconciliation should not each re-solve payments and data access. Define the capability once and compose it many times. Keep provider configuration with the component so features can build on a shared foundation.
Tour / How it works
The same mental model everywhere, workbench, CLI, SDK, and desktop.
Create a product in the workbench, the boundary for your app or service line.
Define reusable capabilities across APIs, data stores, queues, and storage. Configure each environment.
Use the SDK with access keys. What you configured is what executes, with retries, logs, and traces included.
From zero to a running call in a few minutes on cloud, or point the desktop app at your self-hosted instance.
Sign up on cloud or sign in to your organization’s self-hosted workbench.
Add dev (and later staging/prod). Generate access keys for the SDK.
npm install @ductape/sdk (or your stack). Register an API or database, then invoke it from your app.
Resources are managed infrastructure primitives, attach them to a product and configure per environment, same as in the workbench resource browser.
Tour / Marketplace
Pre-built apps and templates from partners and the community, install into your product in a click.
Skip weeks of integration work for common providers. Customize after import to match your environments and policies. Open marketplace →
Collaborate with providers and customers in the workbench: messages, deliverables, and scoped access, including secrets you choose to share across workspaces.
Building an integration? Partner with us → · Publish to marketplace →
Keep API keys, tokens, and connection strings out of repos and chat. Ductape stores them in an encrypted vault per product and environment, injects them at runtime through the SDK, and lets you share scoped access with partner workspaces when you collaborate, without copying credentials by hand.
Define secrets once per product, with separate values for dev, staging, and production. Wire components to secret names in the workbench; the SDK resolves the right value for the active environment on every call.
When you work with a provider or customer in Partnerships, grant their workspace access only to the secrets you approve. They consume secrets through Ductape’s runtime, not files you email or duplicate in .env spreadsheets.
Values are encrypted at rest. Secret access is recorded in Workspace Logs so your team can audit who touched which secret and when. Rotate or revoke in the vault without hunting keys across repos.
Secrets are part of the same control plane as products, environments, and marketplace apps: configure in the workbench, run from the SDK, collaborate with partners when you are ready. Partnerships → · Secrets docs →
Tour / SDK
One client library for server and browser, same component names, environments, and access keys you set in the workbench.
Switch to SDK playground for runnable examples in every language.
Pick backend or frontend, language, and example, copy into your project.
Tour / Connect
Every component becomes something your team and your agents can use again. Define the capabilities your software depends on. Turn them into a foundation for the next feature.