Skip to main content
Some workflows look parallelizable but aren’t. Activate two nodes simultaneously and they interfere. Start two services at the same time and they deadlock. Send two API calls without waiting for the first to resolve and you corrupt state. Stratus was benchmarked on the Signal Router level — where 5 nodes must be activated in strict sequence, and triggering any paired nodes simultaneously causes an ERROR. Paired with the Temporal Relay level — 7 stations, boosts, reroutes, and interference windows — this is Stratus at its most surgical.

Sequence Inference

Stratus predicts dependency chains from state descriptions alone — no explicit DAG required.

Conflict Detection

Identifies when two planned actions would conflict in a shared downstream state before either fires.

Timing Awareness

Models temporal windows — knows when to wait, boost, or reroute based on predicted state evolution.

​
The Problem

A deployment pipeline where services must start in a specific order. If auth-service and api-gateway both try to register with the service mesh simultaneously, the mesh rejects one with a conflict error. The correct sequence is: 
database → cache → auth-service → api-gateway → frontend
But a naive agent might try to parallelize auth-service and api-gateway — triggering the conflict.

​
The Agent

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.stratus.run/v1',
  apiKey: process.env.STRATUS_API_KEY
});

interface ServiceState {
  running: string[];
  pending: string[];
  conflicts: string[][];  // pairs that can't run simultaneously
}

async function planDeployment(state: ServiceState, goal: string) {
  const conflictDescription = state.conflicts
    .map(pair => `[${pair.join(' + ')}] cannot register simultaneously`)
    .join(', ');

  const stateDescription = `
    Deployment orchestrator.
    Running services: ${state.running.join(', ') || 'none'}.
    Pending deployment: ${state.pending.join(', ')}.
    Service mesh constraints: ${conflictDescription}.
    Action: trigger-start <service-name> to begin deployment.
  `.trim();

  const response = await client.chat.completions.create({
    model: 'stratus-x1ac-base-gpt-4o',
    messages: [
      { role: 'system', content: `Current state: ${stateDescription}` },
      { role: 'user', content: goal }
    ]
  });

  return {
    action: response.choices[0].message.content,
    sequence: response.stratus.action_sequence,
    confidence: response.stratus.overall_confidence
  };
}

async function deployStack() {
  const steps = [
    {
      state: {
        running: [],
        pending: ['database', 'cache', 'auth-service', 'api-gateway', 'frontend'],
        conflicts: [['auth-service', 'api-gateway']]
      },
      goal: 'Deploy all services in the correct order to avoid mesh registration conflicts'
    },
    {
      state: {
        running: ['database'],
        pending: ['cache', 'auth-service', 'api-gateway', 'frontend'],
        conflicts: [['auth-service', 'api-gateway']]
      },
      goal: 'Continue deployment — database is running'
    },
    {
      state: {
        running: ['database', 'cache'],
        pending: ['auth-service', 'api-gateway', 'frontend'],
        conflicts: [['auth-service', 'api-gateway']]
      },
      goal: 'Deploy auth-service and api-gateway without triggering a mesh conflict'
    }
  ];

  for (const [i, step] of steps.entries()) {
    const result = await planDeployment(step.state, step.goal);
    console.log(`Step ${i + 1}:`);
    console.log('  Action:', result.action);
    console.log('  Sequence:', result.sequence.join(' → '));
    console.log('  Confidence:', result.overall_confidence, '\n');
  }
}

deployStack();

​
Encoding Interference Constraints

The more explicitly you describe constraints in the state, the more precisely Stratus can plan around them. 
"Services need to be deployed carefully"
Stratus doesn’t know what “carefully” means in terms of state transitions. Confidence: ~0.63

​
Timing Windows

Some operations need to happen within a time window. Encode that directly: 
const state = `
  Background job processor.
  Job A: running, 45s elapsed, max 60s window.
  Job B: queued, depends on Job A completion.
  Job C: queued, independent, can start immediately.
  CONSTRAINT: Job B must start within 5s of Job A completing or it times out.
`;

const result = await client.chat.completions.create({
  model: 'stratus-x1ac-base-gpt-4o',
  messages: [
    { role: 'system', content: `Current state: ${state}` },
    {
      role: 'user',
      content: 'Start Job C now, then immediately queue Job B to start when Job A completes'
    }
  ]
});

// Stratus predicts the timing sequence:
// start-job-c → monitor-job-a → trigger-job-b-on-completion
console.log('Sequence:', result.stratus.action_sequence);

​
Using Rollout for Pre-Validation

Before committing to a deployment sequence, validate the full plan against your constraints: 
const validation = await fetch('https://api.stratus.run/v1/rollout', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.STRATUS_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    goal: 'Deploy all 5 services without mesh conflicts',
    initial_state: 'All services pending. auth-service and api-gateway conflict if concurrent.',
    max_steps: 10
  })
}).then(r => r.json());

if (validation.summary.outcome === 'success') {
  const deployOrder = validation.predictions.map(p => p.action.action_name);
  console.log('Safe deployment order:', deployOrder);
  // Execute this exact sequence
}

​
Real-World Use Cases

CI/CD Pipelines

Parallel test runners that share fixtures, deploy steps with rollback windows, blue-green cutover timing.

Database Migrations

Schema changes that lock tables, foreign key updates with cascade constraints, index rebuilds with read locks.

Microservice Orchestration

Service mesh registration ordering, health check dependencies, distributed lock acquisition sequences.

Event-Driven Systems

Kafka consumer group rebalances, Saga compensation ordering, idempotency window management.

​
Next Steps

Concurrent Tasks

Manage multiple parallel threads that need to coordinate without interfering.

Rollout API

Pre-validate sequences before committing to execution.

Cascade Prediction

Handle chain reactions triggered by a single action.