---
title: "Production runtime for durable AI agents"
description: "The Duale AI production runtime keeps Python agent contracts stable while models, providers, and routing policy evolve."
lang: en
lastUpdated: 2026-08-31
url: https://dev.duale.ai/
---

<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/docs/sdk.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 AI runs orchestration, and your team owns policy.">
  ```mermaid
  flowchart LR
      accTitle: Duale AI platform context and containers
      accDescr {
        Your Python code submits work via the Duale AI SDK. Inside Duale AI,
        the Configured zone holds routing policy, deadlines, identity scopes,
        and retention expectations your team owns. The Managed zone runs the
        orchestration, task state, retries, runtime events, tenant isolation, and
        audit events where configured. Duale AI 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 AI]
              Orch(Orchestration, 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/docs/sdk.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 to stop
      automated attempts for project-specific review.
    </Card>

    <Card title="Durable execution" icon="commit">
      Treat agent work as production work: stateful, retry-aware, and visible through the signals the integration
      captures. Choose a deadline hours or days ahead when work needs more time.
    </Card>
  </CardGrid>
</Section>

<Section title="Proof points" subtitle="Current facts for a first product and security review.">
  <CardGrid columns={3}>
    <Card title="Python first" icon="code" href="https://dev.duale.ai/en/docs/sdk.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">
      Review security controls, certification status, subprocessors, contacts, and available review material.
    </Card>
  </CardGrid>
</Section>

## Questions teams ask before putting agents in production

### What do 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.

### Can an agent stay on one task for hours

Yes. Every task deadline is an absolute date. By default, the SDK sets it 30 minutes ahead. You can set it hours or
days ahead instead.

During a long run, the platform sends the model less of the older history but keeps the stored originals. It sends the root task
instruction unchanged on each model call, and the agent can read stored originals back. After the deadline, the task
fails and returns no partial result. Place review checkpoints where the workflow needs them. [Scope and
limits](https://dev.duale.ai/en/docs/scope-and-limits.md) states the boundaries, and [Concepts](https://dev.duale.ai/en/docs/sdk/concepts.md) explains how to design
the task.

### Where do 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

- [One runtime path for production agents by operating role](https://dev.duale.ai/en/solutions.md)
- [Turn AI pilots into a production portfolio](https://dev.duale.ai/en/solutions/business.md)
- [Runtime security and pricing for production agents](https://dev.duale.ai/en/product.md)
- [Govern AI agents while they move to production](https://dev.duale.ai/en/solutions/governance.md)
- [Python SDK for bounded agent work with typed results](https://dev.duale.ai/en/docs/sdk.md)
- [Pricing for reliable agent orchestration](https://dev.duale.ai/en/product/pricing.md)

---

## Sitemap

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