Worker

Agentic Engineering Platform

Turn into shipped code.

Modula coordinates agents through a visible pipeline, with isolated worktrees, provider choice, and every run traceable on your machine.

Download Github

Tasks

ACM-118

Retry provider requests with exponential backoff

description

# Retry provider requests with exponential backoff

Transient provider failures (429s, 5xx, dropped connections) fail a run
on the very first error today. Wrap outbound provider calls in a retry
policy that backs off exponentially with jitter, and give up only after
a bounded number of attempts so a run never hangs indefinitely.

- cap both attempt count and total elapsed time
- add full jitter so retries don't synchronize into storms
- only retry idempotent, safe-to-replay errors

variants

Variant 1AcceptedChangesCreate PRAccepted

runs

PR-CreatorVariant 1just now
Code-ReviewerVariant 112 minutes ago
WorkerVariant 11 hour ago

Diff acm-118/provider-retry-backoffCreate PR

engine +25 −5

src/provider/retry.rs+6−2

1use std::time::Duration;

2use rand::Rng;

2pub fn next_delay(attempt: u32) -> Duration {

3 Duration::from_secs(attempt as u64)

4pub fn next_delay(attempt: u32) -> Option<Duration> {

5 let ceiling = BASE_DELAY.saturating_mul(2u32.pow(attempt)).min(MAX_DELAY);

6 let millis = rand::thread_rng().gen_range(0..=ceiling.as_millis() as u64);

7 Some(Duration::from_millis(millis))

8}

src/provider/client.rs+14−2

40 pub async fn send(&self, req: Request) -> Result<Response, ProviderError> {

41 let resp = self.http.execute(req).await?;

42 resp.error_for_status().map_err(ProviderError::from)

41 let mut attempt = 0;

42 loop {

43 let err = match self.try_send(&req).await {

44 Ok(resp) => return Ok(resp),

45 Err(err) => err,

46 };

47 match next_delay(attempt) {

48 Some(delay) if err.is_retryable() => {

49 sleep(delay).await;

50 attempt += 1;

51 }

52 _ => return Err(err),

53 }

54 }

55 }

56}

src/provider/error.rs+5−1

01Product

A desktop control room for coding agents.

Pipeline by default

Project Manager, Researcher, Worker, Code Reviewer, and Reviewer agents move work forward through event-driven handoffs.

Worktree isolation

Each variant gets a clean branch and worktree so parallel solutions stay separated until you choose what to keep.

Provider choice

Use Claude Code, Codex, OpenCode, or any CLI agent that can stream structured output.

Local state

The engine, dashboard, SQLite database, logs, and workspace notes live on your machine.

02Agents

Compose the pipeline around your workflow.

Modula ships with a practical agent pipeline, and teams can define any number of specialized agents for their own review gates, tools, repositories, and release practices.

Project ManagerConfigurable

ResearcherConfigurable

WorkerConfigurable

Code ReviewerConfigurable

ReviewerConfigurable

PlannerConfigurable

DispatcherConfigurable

BuilderConfigurable

TesterConfigurable

RefactorerConfigurable

IntegratorConfigurable

ReleaseConfigurable

03Agnostic

Connect the work systems and coding tools you already use.

Modula is designed around portable tickets, issues, and tasks, and can route them through the LLM coding providers that fit your team.

Provider agnostic

Use the coding agents you trust.

Assign work to first-party and third-party CLI coding tools without restructuring the pipeline around one model vendor.

Claude CodeCodexOpenCode+More coming soon

Source agnostic

Start from any issue system.

Bring in tickets, issues, and tasks from the systems where product and engineering work is already planned.

JiraLinearGitHub Issues