---
title: "Deploy durable AI agents with stable contracts and routing"
description: "Production runtime for durable AI agents with stable contracts, model routing, deadlines, retries, and audit signals for Python developers and platform teams."
lang: en
lastUpdated: 2026-06-07
url: https://dev.duale.ai/en/home
---

## AI-generated summary

The Duale AI page explains a production runtime for durable AI agents that stabilizes input‑output contracts, routes models by policy, enforces deadlines, retries, and provides review signals for platform, IT, governance. It outlines features, proof points, and FAQs to help teams decide if it fits pilot needs.

- Agents stall because pilots lack shared runtime, models change, and production requires proof of cost, policy, and error visibility.
- The Duale AI runtime separates Configured zones (policy, deadlines, identity, retention) owned by the customer from Managed zones (router, retries, audit) operated by Duale.
- The platform provides stable input-output contracts, policy-driven model routing, and durable execution with stateful, retry-aware behavior visible through integration signals.
- Proof points include Python‑first SDK support, managed data hosting in Germany, and a Trust Center with security posture, certifications, subprocessors, and review inputs.
- FAQs note Duale AI does not replace model providers, that durability means a stable contract while models change, and that security teams should start at the Trust Center.

Summaries were generated by AI. Generative AI is experimental.

---

<Hero
  title={
<>
  Production runtime for <AccentText>durable AI agents</AccentText>
</>
}
  subtitle="Duale AI helps platform teams move one bounded Python agent path from pilot to production: stable input and output contracts, provider routing policy, deadlines, recovery behavior, and review inputs tied to what the integration captures."
  primaryCta={{ label: "Review a production path", dialog: "contact" }}
  secondaryCta={{ label: "Explore the Python SDK", href: "https://dev.duale.ai/en/solutions/developers.md" }}
/>

<Section title="Why agent projects stall" subtitle="Model access is becoming easier. The hard part is turning agent work into bounded, reviewable production work that can survive provider and policy changes.">
  <CardGrid columns={3}>
    <Card title="Pilots do not scale by themselves" icon="rocket">
      A handful of prototypes can run on scripts, notebooks, or cloud-specific services. A portfolio of production
      agents needs shared runtime primitives.
    </Card>

    <Card title="Models are replaceable" icon="layers">
      Small, cheap, specialized, and frontier models will keep changing. The platform keeps the agent contract stable
      while provider choices evolve.
    </Card>

    <Card title="Production needs proof" icon="check">
      Platform, business, security, and audit teams need the same view of task identifiers, errors, policy inputs, and
      cost signals that each project actually captures before agent work reaches production.
    </Card>
  </CardGrid>
</Section>

<Section title="How Duale AI fits in your stack" subtitle="Submit work with a deadline. A typed result returns later. Your apps bring the task, your model provider remains selectable where supported, Duale runs orchestration, and your team owns policy.">
  ```mermaid
  flowchart LR
      %% WHAT: Context view of three outer zones with Configured and Managed sub-zones inside Duale.
      %% WHO: Mixed home-page visitor: business sponsor, platform lead, and governance reviewer before discovery.
      %% WHY: Shows what runs where and what stays customer-owned.
      %% NOT: Real-time chat loop, customer-managed deployment, admin console, or long autonomous-run claim.
      accTitle: Duale AI platform context and containers
      accDescr {
        Your Python code submits work via the Duale AI SDK. Inside Duale,
        the Configured zone holds routing policy, deadlines, identity scopes,
        and retention expectations your team owns. The Managed zone runs the
        router, task state, retries, runtime events, tenant isolation, and
        audit events where configured. Duale sends work to the model provider
        selected for the deployment. Results return asynchronously to your apps.
      }

      Apps(Your apps and Python code)
      subgraph Duale[Duale AI platform]
          subgraph Configured[Configured by your team]
              Policy(Routing policy, deadlines, identity scopes, retention expectations)
          end
          subgraph Managed[Managed by Duale]
              Orch(Router, task state, retries, recovery)
              Records(Runtime events, tenant isolation, audit events where configured)
          end
      end
      ModelProvider(Selected model provider)

      Apps <-.-> Duale
      Configured --> Managed
      Duale <--> ModelProvider
  ```
</Section>

<Band>
  <Section title="One runtime, three operating views" subtitle="Submit bounded work with a deadline. The runtime returns a terminal result, and each team reads the signals available for that project.">
    <CardGrid columns={3}>
      <Card title="For platform leads" icon="code" href="https://dev.duale.ai/en/solutions/developers.md">
        Build Python agents on stable input and output contracts. Route models by policy, recover failed work, use task
        identifiers, and keep the deployment path understandable.
      </Card>

      <Card title="For information technology leaders" icon="bar-chart" href="https://dev.duale.ai/en/solutions/business.md">
        Turn scattered pilots into a portfolio with cost visibility, provider choice, and a clearer path from business
        demand to operated software.
      </Card>

      <Card title="For security and governance" icon="lock-closed" href="https://dev.duale.ai/en/solutions/governance.md">
        Review data movement, subprocessors, retention, and incident paths from project-specific evidence instead of a
        separate after-the-fact narrative.
      </Card>
    </CardGrid>
  </Section>
</Band>

<Section title="What the platform provides" subtitle="The product boundary is the agent runtime: the stable layer between your application, your providers, and your operational controls.">
  <CardGrid columns={3}>
    <Card title="Stable contracts" icon="file-text">
      Define the work an agent can receive and the result it must return. The model, provider, timeout, retry behavior,
      and review policy can evolve around that contract.
    </Card>

    <Card title="Model routing" icon="mixer-horizontal">
      Use policy to decide when a smaller model is enough, when a stronger model is justified, and when an automated
      attempt should stop for project-specific controls.
    </Card>

    <Card title="Durable execution" icon="commit">
      Treat agent work as production work: stateful, retry-aware, and visible through the signals the integration
      captures.
    </Card>
  </CardGrid>
</Section>

<Section title="Proof points" subtitle="Clear enough for a first review, without pretending the platform is more mature than it is.">
  <CardGrid columns={3}>
    <Card title="Python first" icon="code" href="https://dev.duale.ai/en/solutions/developers.md">
      The supported developer path today is Python: contracts, deadlines, typed results, runtime events, and provider
      choices for production agent work.
    </Card>

    <Card title="Managed in Germany" icon="globe" href="https://dev.duale.ai/en/legal/subprocessors.md">
      Managed application data is hosted in Germany today. Subprocessors and transfer posture are documented in the
      legal pages.
    </Card>

    <Card title="Trust Center" icon="reader" href="https://dev.duale.ai/en/product/security.md">
      Security posture, certification status, subprocessors, contacts, and requestable review inputs are summarized
      without unsupported badge claims.
    </Card>
  </CardGrid>
</Section>

## Questions teams ask before putting agents in production

### What should we bring to a first production review

One bounded Python agent path: the task action and typed result, the deadline, the routing policy, and the model
providers in scope. Duale AI handles task identity, routing, retries, and the terminal result; your integration
brings the contract and the data movement the reviewers need to inspect.

### Does Duale AI replace our model providers

No. Duale AI is not a hidden bundled provider. You keep your accounts with OpenAI, Anthropic, AWS Bedrock, Microsoft
Foundry, Vertex AI, and others; routing policy decides which one each task uses. Models stay replaceable, the agent
contract stays stable.

### What does durable mean here

Durable here is the product category: the agent contract your application depends on stays stable while models,
providers, and routing policy change underneath. Models can change; production contracts must not.

### Where should security and audit teams start

Start with the Trust Center. It is the entry point for the data-processing agreement request path, the hosting
description, the security and incident contact channels, and links into the legal pages for the current subprocessor
list.

### How is this different from an agent framework or starter pack

Different layer. Frameworks help you write an agent; starter packs scaffold one. Duale AI is the governed runtime
layer around the agent work: routing policy, deadlines, retries, and a typed terminal result, on a contract that
stays stable while providers and projects change. Make models replaceable and agents durable.

<Cta title="Plan the path from pilots to production agents." primaryCta={{ label: "Review a production path", dialog: "contact" }} secondaryCta={{ label: "See pricing model", href: "https://dev.duale.ai/en/product/pricing.md" }} />

<JsonLd
  data={{
"@context": "https://schema.org",
"@type": "SoftwareApplication",
name: "Duale AI",
applicationCategory: "BusinessApplication",
description:
  "Production runtime for durable AI agents with stable contracts, routing policy, deadlines, recovery behavior, and review inputs tied to current integrations.",
operatingSystem: "Web",
}}
/>

## Related content

- [Role-based solutions for production AI agents](https://dev.duale.ai/en/solutions.md)
- [Use Python SDK for stable contracts, routing, and retries](https://dev.duale.ai/en/solutions/developers.md)
- [Turn AI pilots into a production portfolio](https://dev.duale.ai/en/solutions/business.md)
- [Govern AI agents with shared operating model for compliance](https://dev.duale.ai/en/solutions/governance.md)
- [Pricing for reliable AI agent orchestration](https://dev.duale.ai/en/product/pricing.md)
- [Review security posture for production AI agents](https://dev.duale.ai/en/product/security.md)

---

## Sitemap

See the full [Markdown sitemap](https://dev.duale.ai/sitemap.md) for all pages.