In the early days of AI agents, the pitch was slick: tools that would take work off your plate, understand what you need, and magically get it done.
What we actually got? Clippy with a language model.
Bots that couldn’t remember what you just said. “Smart” agents that needed you to paste the entire project brief into a text box just to get started. Like asking for help moving a couch and being told to list all the furniture in the house first. Helpful… but only if your definition of helpful was “vague summaries and a shrug.”
Dust is flipping the script.
They’re building teammates — AI agents that live in your stack, follow your processes, and actually ship work. These agents don’t just live in a sidebar. They integrate directly into your tools, your workflows, and your team’s habits.
Making that magic happen takes more than a good prompt. It requires a product-driven engineering team, a serious perspective on scale, and an orchestration backbone to keep it all running. That’s where Temporal comes in.
Building a Platform Around Context
Dust’s AI understands. Their agents aren’t sitting outside your workflows waiting for input. They’re embedded in the systems you already use: Slack, Notion, GitHub, Confluence, Salesforce, and more.
This gives Dust agents a superpower: context.
When a pull request opens, an agent can comment based on the design doc that led to it. If a bug comes up in Slack, the agent can create a ticket: assigned, categorized, and formatted to match internal standards.
These aren’t stateless bots. They’re live, real-time Workflows built with company data and triggered by actual events.
“We aim to be both horizontal and flexible by design,” Stan Polu, co-founder and CTO, notes. “We understand that the one-size-fits-all approach will never work for enterprise.”
That’s why Dust’s platform spreads organically across organizations. Anyone can build their own agent but this kind of adoption happens bottom-up, driven by real use cases, not forced rollouts.
However, to support that kind of speed and autonomy, you need orchestration that doesn’t fall over. Dust needed to keep everything in sync, without sacrificing reliability or scale.
How Engineering Culture Shapes Product
Dust’s product reflects how the team works internally. The engineering culture is fast-moving, product-led, and deeply focused on ownership. Engineers drive initiatives end to end — discovery, user feedback, scoping, building, shipping, and even external communication.
There’s no separate track for “just building features.” Every engineer operates like a full-stack product team. This model isn’t just efficient, it shapes the kinds of systems Dust needs to build.
“Engineers are the Directly Responsible Individuals (DRIs) for product initiatives,” says Stan. “They don’t do everything alone, but they are responsible for it moving forward. That creates a sense of momentum and clarity that top-down prioritization can’t match.”
Because of this structure, Dust’s platform must be both powerful and adaptable. New ideas come from within, and the tooling has to support fast iteration, safe changes, and the ability to move quickly without compromising core infrastructure.
The team moves fast, but never recklessly. Security is non-negotiable. With a strong foundation, they focus on maintaining momentum by shipping quickly and cleaning things up as they go. Temporal gives them the confidence to build at this pace without sacrificing stability.
Temporal fits into a broader pattern in how Dust builds: autonomous teams using reliable systems to deliver real results, quickly.
How Dust Uses Temporal to Keep Everything in Sync
From the beginning, Dust has relied on Temporal as the orchestration engine powering its agent platform.
Whenever a Slack message is posted, a Notion doc is updated, or a pull request is created, a Temporal Workflow is triggered. That Workflow might pull data, transform it, run AI processing, and update internal indexes. It might respond back to the platform or kick off a follow-up action. Some Workflows last seconds; others span hours.
Temporal also powers Dust’s Tracker product, which monitors for stale documents based on internal activity and triggers agent-led updates to things like coding guidelines or internal processes. These are complex Workflows. They may involve polling APIs, running AI tasks, and proposing structured changes; all of which require persistence, retry logic, and state.
Tracker does so much more than keeping documentation fresh. It also acts as a kind of agent-for-agents. It monitors conversations, code, and processes to suggest updates to AI agents’ prompts, coding rules, and internal guidance. In doing so, Dust closes the loop between learning and doing.
“Ingesting company data requires complex orchestration with Actions that can be retried that depend on each other in complex ways,” Stan explains. “Temporal felt like a perfect fit.”
Trying to build this orchestration layer on top of a traditional queue system would have meant custom logic for retries, timeout handling, state recovery, and failure coordination across dozens of async steps. Temporal replaces all of that with a built-in, durable Workflow model.
And if you’re thinking, “Okay, but what about observability?” it’s not an afterthought. Temporal gives you a real-time view into every Workflow, so when something does go wrong, you don’t dig through scattered logs. You just look it up.
Dust runs over 10 million Temporal Activities per day on Temporal Cloud. There’s no custom infrastructure for scale. When the load increases, they just run more workers. The rest of the system is built on PostgreSQL, GCS, and Kubernetes.
Workflows are deeply instrumented with Datadog, giving engineers real-time visibility into every retry, error, and completion event without log-diving.
“It’s Temporal all the way down for orchestration,” Stan expounds. “Scaling just means running more Workers.”
Temporal’s native support for long-running Workflows via [continueAsNew] and built-in visibility features allow Dust to focus on product-building rather than writing glue code for orchestration and recovery. Beyond a framework choice, it’s part of Dust’s design philosophy.
Temporal has changed how the team thinks about building reliable systems. Instead of stitching together ad hoc retries and error handling, Dust treats Workflows as durable, inspectable units of business logic.
The Architecture Behind Workflows
The diagram below shows how Dust uses Temporal as the backbone of its orchestration system.
At the center is the connectors service, which manages real-time data ingestion from tools like Slack, Notion, Confluence, and GitHub. Each incoming event (new message, document edit, or pull request) triggers a Temporal Workflow that handles ingestion, enrichment, and indexing.
Long-running or resource-intensive tasks, like document chunking and embedding, are managed asynchronously as Temporal Activities, ensuring responsiveness without blocking other parts of the system.
The architecture is designed to scale horizontally. Workers can be added dynamically to meet demand, and Temporal Cloud handles the state, retries, and execution flow. Observability is instrumented in the Temporal stack with Datadog, providing deep visibility into Workflows across the entire system.
This approach lets Dust maintain near real-time data synchronization with minimal operational overhead.
A Look Inside: Real-Time Ingestion with Temporal
One example of this architecture in action is Dust’s GitHub connector. When a repository is connected, a Temporal Workflow is triggered to ingest, filter, and index its contents. The following code snippet, adapted from Dust’s open-source repo, illustrates how they filter files during repository extraction before sending them downstream for indexing:
const EXTENSION_WHITELIST = [".ts", ".js", ".py", ".md", ".yaml"];
await extract({
file: tarPath,
cwd: tempDir,
filter: (path, stat) => {
if (path.endsWith("/")) return true;
const ext = extname(path).toLowerCase();
const isUnderLimit = stat.size < 1024 * 1024;
const isWhitelisted = EXTENSION_WHITELIST.includes(ext);
return isUnderLimit && isWhitelisted;
},
onentry: onEntry,
});
This logic runs inside a Temporal Activity, managed as part of a broader Workflow that handles repo syncing across the platform. If a failure occurs, say, during a download or parsing step, Temporal automatically retries the Activity and resumes execution precisely from the point of failure. No lost work, no dangling jobs.
It’s a clean example of the kind of stateful, retry enabled, and observable orchestration that underpins Dust’s platform — and showcases exactly why Temporal is such an essential component of that foundation.
What’s Next?
Dust is focused on deepening agent capabilities and expanding integrations with more enterprise platforms. As new products like Doc Tracker mature, orchestration demands will only grow, but with Temporal at the foundation, the team won’t have to worry about reliability or retry logic. They’re free to move swiftly and build confidently.
The long-term goal is to make AI agents not just useful, but foundational to how teams operate: handling real Workflows, surfacing genuine insights, and evolving alongside the business. Temporal makes that possible, serving as the reliable execution engine behind every interaction.
Want to see how Dust builds AI infrastructure in the open? Check out their GitHub, follow them on Twitter/X or LinkedIn, and explore more at dust.tt.
Get started today building something great, just like Dust, with a free trial and $1,000 in credits with Temporal Cloud.