The usual way
AI moves fast. Production context stays fragmented.
- Every team reimplements the same integrations
- Agents given unrestricted access to codebases
- No single source of truth for what exists
- Standards drift as the organization grows
Tour / Welcome
Ductape framework
The AI-Native Framework for Building Production Systems
Build reliable software with developers and AI agents working from the same production-ready foundation. Agents discover and use governed capabilities through MCP. Applications ship through the SDK. Authentication, environments, retries, and observability stay built in.
What we offer
Everything developers and AI agents need to build, operate, and evolve production systems.
SDK InstallDocs
Backend and frontend packages, TypeScript, Nest, Go, Java, .NET, Python, React, Vue, and more. One surface for every component you configure.
Workbench CloudSelf-hosted
Visual control plane for products, apps, environments, and resources. Cloud-hosted or deployed in your VPC, same UI and APIs.
Desktop (macOS & Windows) Download
Native workbench clients with the same experience as cloud, connect to cloud or your self-hosted instance.
CLI CLI docs
Seed environments, export configs, and wire CI/CD without clicking through the UI.
MCP server MCP guide
Connect assistants such as Codex, Claude, and Cursor to Ductape. Agents can discover workspace apps and infrastructure, inspect exact action schemas, generate valid payloads, and execute only the governed capabilities you expose.
Environments & deployment
Where Ductape runs, and how you isolate config per stage.
Cloud Start free
Managed workbench, automatic updates, fast onboarding. Best when you want to ship in minutes without operating control plane infrastructure.
Self-hosted Deploy guideTalk to us
Run the workbench in your VPC or on-prem. You own networking, backups, and compliance boundaries, feature parity with cloud.
Multiple environments per product Getting started
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
Production systems need an AI-native foundation
AI can generate code. Production still demands architecture, security, reliability, operational context, and control. Ductape brings both together through an MCP interface for agents and SDKs for running applications.
One AI-native framework
Define once. Govern centrally. Enable everyone.
- Capabilities defined once, reused across every team
- Agents get governed access to approved capabilities only
- One source of truth for every capability you have built
- Consistent policies enforced across all teams and agents
Use the tabs above to explore how Ductape governs capabilities across developers, agents, and teams.
Developers and AI agents, building on the same system.
Instead of handing agents unrestricted access to code and infrastructure, Ductape exposes typed, governed production capabilities through MCP. Developers use the SDK against the same framework, under the same policies and operational boundaries.
One control plane. Same governance for everyone.
Every capability in the control plane carries its own authentication, environment configuration, retry policies, observability, and access rules. Developers import capabilities through the SDK. Agents discover schemas, generate payloads, and invoke approved actions through MCP. Both operate against the same source of truth.
What the control plane governs
- Authentication & credentials
- Per-environment configuration
- Retry & fallback policies
- Observability & audit trail
- Secrets, injected at runtime
- Access permissions per team and agent
What your organization gains
- One source of truth for every capability
- No more tribal knowledge or scattered repos
- Agents operating within organizational rules
- Standards enforced without manual coordination
- Reusable capabilities across every team
- Empower developers. Enable AI.
Build with AI. Ship with production discipline.
One framework from intent to production.
Ductape turns APIs, databases, models, workflows, storage, and messaging into reusable production primitives. MCP makes them discoverable and actionable for AI agents; the SDK makes them executable in your applications.
One SDK. Every capability. Every environment.
- APIs, databases, AI models, workflows, storage, messaging
- Per-environment config with no code changes
- Retries & fallbacks defined in the control plane
- Central observability and audit trail
- Secrets injected at runtime from the vault
- TypeScript, NestJS, Go, Java, .NET
Your developers import governed capabilities. Your agents operate within the same governance. Neither reimplements what the control plane already provides.
A control plane that grows with your organization
Every capability you define becomes part of the control plane. The next team starts with everything the previous team already built. No more hunting through repositories. No more tribal knowledge. Your platform becomes the canonical record of every capability your organization has.
Tour / How it works
Define. Govern. Enable.
Define production capabilities once, attach the context required to run them safely, and make them available to every developer and AI agent through one framework.
- 1
Define your capabilities
In the workbench, define every capability your organization depends on: APIs, databases, AI models, workflows, storage, messaging. Each carries its own authentication, environments, retry logic, and observability.
- 2
Set governance policies
Define the operational standards that apply across your organization: retry behavior, failover rules, access permissions, observability standards. Set once. Inherited everywhere.
- 3
Connect agents through MCP
AI agents inspect the capabilities and exact schemas available to them, generate valid payloads, and act within governed workspace boundaries. Developers compose the same primitives through the SDK.
Getting started
From zero to a running call in a few minutes on cloud, or point the desktop app at your self-hosted instance.
- 1
Create an account
Sign up on cloud or sign in to your organization’s self-hosted workbench.
- 2
Create a product & environment
Add dev (and later staging/prod). Generate access keys for the SDK.
- 3
Install the SDK & connect a component
npm install @ductape/sdk(or your stack). Register an API or database, then invoke it from your app.
Resources & primitives
Resources are managed infrastructure primitives, attach them to a product and configure per environment, same as in the workbench resource browser.
Pre-built templates? Open marketplace → · Workbench →
Tour / Marketplace
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 →
Partnerships
Collaborate with providers and customers in the workbench: messages, deliverables, and scoped access, including secrets you choose to share across workspaces.
- Certified apps: reviewed actions, webhooks, and environment templates from technology partners.
- Co-built templates: vertical starters (fintech, health, commerce) you extend instead of building from scratch.
- Cross-workspace collaboration: work with partners without emailing keys; share secrets securely when the partnership requires it.
Building an integration? Partner with us → · Publish to marketplace →
Secrets
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.
In your workspace
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.
Across partnerships
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.
Governance
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.
What you get
- Central vault: API keys, OAuth tokens, database URLs, and other sensitive strings live in the workbench, not in application source or shared drives.
- Runtime injection: apps and workflows reference secret names; nothing sensitive ships in client bundles or container images.
- Environment isolation: the same component in dev and prod automatically picks up the correct secret value for that environment.
- Scoped partner access: during an active partnership, share only what the other workspace needs to integrate or operate, with boundaries you control.
- Audit trail: access events show up alongside the rest of your workspace activity, so security and platform teams have one place to review usage.
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
SDK overview
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.
Code that just works
Pick backend or frontend, language, and example, copy into your project.
Server-side · access keys
notifications.ts
Backend · TS
Tour / Connect