Hybrid AI Workflows: Combining DeepSeek-R1 Reasoning with Claude Sonnet Coding

How to Build a DeepSeek-R1 + Claude Sonnet Hybrid Workflow

1. Configure API keys for DeepSeek and Anthropic in a .env file and install Node.js dependencies.
2. Build a DeepSeek-R1 reasoning client that returns structured JSON architecture plans.
3. Build a Claude Sonnet coding client that accepts the reasoning plan as context and generates implementation code.
4. Implement a complexity router that classifies prompts as hybrid or direct using keyword heuristics.
5. Create an Express API endpoint that orchestrates the two-phase pipeline with validation and fallback handling.
6. Bootstrap a React frontend with Vite that displays reasoning plans and generated code in a dual-panel layout.
7. Optimize cost and latency by caching reasoning outputs, truncating verbose plans, and setting aggressive timeouts.
8. Harden for production with rate limiting, structured JSON logging, retry logic, and degraded-mode monitoring.

A DeepSeek-R1 Claude Sonnet hybrid workflow addresses a persistent tension in LLM development: no single model excels at every task. This tutorial walks through building a Node.js orchestration layer with a React frontend that demonstrates a multi-model AI workflow in action.

Table of Contents

• Why One AI Model Isn't Enough
• Understanding the Strengths of Each Model
• Architecture of a Hybrid AI Workflow
• Setting Up the Project
• Building the Orchestration Layer in Node.js
• Adding a React Frontend
• Optimizing Cost and Latency
• Production Considerations
• Implementation Checklist
• Next Steps

Why One AI Model Isn't Enough

Developers building with large language models face a persistent tension: no single model excels at every task. A DeepSeek-R1 Claude Sonnet hybrid workflow addresses this directly by routing complex reasoning to one model and code generation to another, cutting costs and improving output quality simultaneously. The pattern is straightforward: DeepSeek-R1 handles chain-of-thought reasoning and architectural planning, while Claude Sonnet 4 produces precise, idiomatic code. Defaulting to a single LLM for everything leads either to cost bloat (overpaying for simple tasks) or quality gaps (forcing a code-optimized model to handle nuanced design decisions it wasn't built for).

This tutorial walks through building a Node.js orchestration layer with a React frontend that demonstrates a multi-model AI workflow in action. Intermediate JavaScript knowledge and familiarity with REST APIs are assumed throughout.

Understanding the Strengths of Each Model

DeepSeek-R1: Deep Reasoning and Architectural Thinking

DeepSeek built R1 for multi-step logical reasoning. It breaks down ambiguous requirements into structured plans. It evaluates architectural tradeoffs. It selects appropriate algorithms. It produces chain-of-thought analysis that maps complex problems into actionable steps. Its reasoning traces are detailed and methodical, making it well suited for tasks where the "what to build" and "why" matter more than the literal code.

The tradeoffs are real, though. R1's code output is verbose. Formatting inconsistencies appear in longer responses. Response times for code-heavy prompts run 2 to 4 times slower than models optimized specifically for generation tasks.

Claude Sonnet 4: Precise Code Generation

Where Sonnet falls short is in complex architectural reasoning. Without a solid plan provided as context, it oversimplifies design decisions, omits edge cases in system design, or makes assumptions about requirements that a dedicated reasoning step would have surfaced.

Sonnet is optimized to implement code. It produces idiomatic JavaScript and TypeScript, follows established coding conventions reliably, and handles structured output with minimal coaxing. Response times for implementation tasks land in the 2 to 5 second range (per the benchmarks below), and the code it generates typically follows single-responsibility patterns and passes standard linting rules without modification.

Why Hybrid Beats Single-Model

Prices shown are approximate as of mid-2025. Verify current rates at platform.deepseek.com and anthropic.com/pricing before making cost projections.

The cost difference on output tokens is striking. Routing reasoning work to R1 at $2.19 per million output tokens versus running everything through Sonnet at $15.00 per million output tokens adds up fast.

For 10M output tokens per month, that's roughly $21.90 with R1 versus $150.00 with Sonnet on the reasoning phase alone.

Architecture of a Hybrid AI Workflow

The Two-Phase Pipeline Pattern

The orchestration follows a sequential two-phase pipeline:

1. Reasoning -- The user's high-level request goes to DeepSeek-R1. The system prompt constrains R1 to return a structured plan containing architecture decisions, step-by-step implementation logic, and key considerations. This output is JSON-formatted for reliable parsing.
2. Implementation -- R1's structured reasoning output feeds directly into Claude Sonnet as context, alongside a code generation instruction. Sonnet receives both the original request and the reasoning plan, then produces the implementation code.

The flow is: User Request → Router → DeepSeek-R1 (reasoning) → Structured Plan → Claude Sonnet (coding) → Final Output.

When to Route vs. When to Use a Single Model

Not every request needs the hybrid pipeline. Route simple code tasks ("write a sort function," "convert this JSON to a TypeScript interface") directly to Claude Sonnet. The overhead of a reasoning phase adds latency without improving output quality for straightforward implementations.

Complex tasks requiring design decisions ("build a caching layer with an invalidation strategy," "design a rate limiter that handles distributed deployments") benefit substantially from the hybrid approach. The router uses a complexity heuristic based on keyword analysis and prompt length to make this determination automatically.

Setting Up the Project

Prerequisites and API Keys

The project requires Node.js 18 or later and npm. You need two API keys: a DeepSeek platform API key (from platform.deepseek.com) and an Anthropic API key (from console.anthropic.com). Both go into a .env file that the application loads at startup. Add .env to your .gitignore before making any commits. Never commit API keys to version control.

Project Initialization and Dependencies

// package.json
{
 "name": "hybrid-ai-workflow",
 "version": "1.0.0",
 "type": "module",
 "scripts": {
 "start": "node server.js"
 },
 "dependencies": {
 "@anthropic-ai/sdk": "0.30.0",
 "cors": "2.8.5",
 "dotenv": "16.4.5",
 "express": "4.21.0"
 }
}

# .env
DEEPSEEK_API_KEY=your_deepseek_api_key_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here
DEEPSEEK_BASE_URL=https://api.deepseek.com
ALLOWED_ORIGIN=http://localhost:5173
PORT=3001

Run npm install after creating both files, and commit the generated package-lock.json to pin exact dependency versions. The @anthropic-ai/sdk package provides the official Anthropic client. Node.js 18+ includes native fetch globally, so no additional HTTP client library is needed for the DeepSeek API calls.

Building the Orchestration Layer in Node.js

Creating the DeepSeek-R1 Reasoning Client

Note: DeepSeek's deepseek-reasoner model may handle system messages differently from standard chat models. Verify the current DeepSeek API documentation for system message support. If the system role is unsupported or ignored, move the JSON constraint instruction into the user message instead.

// services/deepseek.js
const DEEPSEEK_BASE_URL =
 process.env.DEEPSEEK_BASE_URL || "https://api.deepseek.com";
const DEEPSEEK_API_KEY = process.env.DEEPSEEK_API_KEY;
const TIMEOUT_MS = 30000;
const REASONING_SYSTEM_PROMPT = `You are an expert software architect. Analyze the given request and return a JSON object with exactly these fields:
- "architecture": A string describing the high-level design approach
- "steps": An array of strings, each a concrete implementation step
- "considerations": An array of strings noting edge cases, performance concerns, or tradeoffs
Return ONLY valid JSON. No markdown fencing, no explanation outside the JSON.`;
export async function getReasoningPlan(userPrompt) {
 const controller = new AbortController();
 const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
 try {
 const response = await fetch(`${DEEPSEEK_BASE_URL}/v1/chat/completions`, {
 method: "POST",
 headers: {
 "Content-Type": "application/json",
 Authorization: `Bearer ${DEEPSEEK_API_KEY}`,
 },
 body: JSON.stringify({
 model: "deepseek-reasoner",
 messages: [
 { role: "system", content: REASONING_SYSTEM_PROMPT },
 { role: "user", content: userPrompt },
 ],
 // temperature is NOT supported by deepseek-reasoner — omitted intentionally
 max_tokens: 2048,
 }),
 signal: controller.signal,
 });
 if (!response.ok) {
 const errBody = await response.text();
 throw new Error(`DeepSeek ${response.status}: ${errBody.slice(0, 300)}`);
 }
 const data = await response.json();
 // Guard against malformed or empty response shapes
 if (!data.choices || data.choices.length === 0 || !data.choices[0].message) {
 throw new Error(
 `DeepSeek returned unexpected response shape: ${JSON.stringify(data).slice(0, 300)}`
 );
 }
 const content = data.choices[0].message.content.trim();
 try {
 return JSON.parse(content);
 } catch (parseErr) {
 throw new Error(
 `R1 non-JSON (${parseErr.message}): ${content.slice(0, 500)}`
 );
 }
 } finally {
 clearTimeout(timeout);
 }
}

The system prompt constrains R1 to return structured JSON rather than free-form text. The deepseek-reasoner model identifier targets R1 specifically. The deepseek-reasoner model does not support the temperature parameter, so it is omitted from the request body. The 30-second timeout prevents the pipeline from stalling if R1's reasoning chain runs long, which happens with highly ambiguous prompts. Note that DEEPSEEK_BASE_URL should be set to the base domain (e.g., https://api.deepseek.com) without a trailing path, since the code appends /v1/chat/completions.

Creating the Claude Sonnet Coding Client

// services/claude.js
import Anthropic from "@anthropic-ai/sdk";
const CLAUDE_TIMEOUT_MS = 60000;
const CODING_SYSTEM_PROMPT = `You are an expert JavaScript/React developer. You will receive a reasoning plan from an architect and a user's original request. Generate clean, well-commented code that follows the plan precisely. Use modern ES module syntax. Include error handling where appropriate. Return ONLY the code with comments — no explanatory prose.`;
export async function generateCode(reasoningPlan, originalPrompt) {
 // Instantiate after key is validated at startup
 const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
 const contextMessage = `## Architect's Plan
${JSON.stringify(reasoningPlan, null, 2)}## Original Request
${originalPrompt}Generate the complete implementation based on the architect's plan above.`;
 const timeoutPromise = new Promise((_, reject) =>
 setTimeout(
 () => reject(new Error("Anthropic request timed out")),
 CLAUDE_TIMEOUT_MS
 )
 );
 const requestPromise = anthropic.messages.create({
 model: "claude-sonnet-4-20250514",
 max_tokens: 4096,
 system: CODING_SYSTEM_PROMPT,
 messages: [{ role: "user", content: contextMessage }],
 });
 const response = await Promise.race([requestPromise, timeoutPromise]);
 // Guard against empty or non-text content blocks
 if (
 !response.content ||
 response.content.length === 0 ||
 response.content[0].type !== "text"
 ) {
 throw new Error(
 `Anthropic returned unexpected content shape: ${JSON.stringify(response.content).slice(0, 200)}`
 );
 }
 return response.content[0].text;
}

The Anthropic SDK handles authentication and request formatting. The reasoning plan from R1 is injected as structured context in the user message, giving Sonnet the full architectural blueprint before it writes a single line of code. The max_tokens is set to 4096 to accommodate substantial code output without truncation. A 60-second timeout via Promise.race prevents a hung Anthropic call from stalling the pipeline indefinitely.

Building the Router and Pipeline Controller

The router uses a complexity heuristic based on keyword analysis and prompt length to make this determination automatically.

// services/router.js
import { getReasoningPlan } from "./deepseek.js";
import { generateCode } from "./claude.js";
const COMPLEXITY_KEYWORDS = [
 "architect",
 "design",
 "system",
 "scalable",
 "strategy",
 "optimize",
 "tradeoff",
 "distributed",
 "cache",
 "invalidat",
 "migration",
 "refactor entire",
 "microservice",
 "pipeline",
];
// Word count is more stable than raw character length
const PROMPT_WORD_THRESHOLD = parseInt(process.env.PROMPT_WORD_THRESHOLD ?? "15", 10);
export function classifyComplexity(prompt) {
 const lower = prompt.toLowerCase();
 const keywordHits = COMPLEXITY_KEYWORDS.filter((kw) =>
 lower.includes(kw)
 ).length;
 const wordCount = prompt.trim().split(/\s+/).length;
 const isLong = wordCount > PROMPT_WORD_THRESHOLD;
 return keywordHits >= 2 || (keywordHits >= 1 && isLong)
 ? "hybrid"
 : "direct";
}
async function directGeneration(prompt) {
 const codingStart = Date.now();
 try {
 const generatedCode = await generateCode(
 { architecture: "Direct implementation", steps: ["Implement as requested"], considerations: [] },
 prompt
 );
 const codingTimeMs = Date.now() - codingStart;
 return {
 reasoningPlan: null,
 generatedCode,
 metadata: {
 model_used: "direct:claude-sonnet",
 reasoning_time_ms: 0,
 coding_time_ms: codingTimeMs,
 total_time_ms: codingTimeMs,
 degraded: false,
 },
 };
 } catch (err) {
 throw new Error(`Direct generation failed: ${err.message}`);
 }
}
export async function executeHybridPipeline(prompt) {
 const reasoningStart = Date.now();
 const reasoningPlan = await getReasoningPlan(prompt);
 const reasoningTimeMs = Date.now() - reasoningStart;
 const codingStart = Date.now();
 const generatedCode = await generateCode(reasoningPlan, prompt);
 const codingTimeMs = Date.now() - codingStart;
 return {
 reasoningPlan,
 generatedCode,
 metadata: {
 model_used: "hybrid:deepseek-r1+claude-sonnet",
 reasoning_time_ms: reasoningTimeMs,
 coding_time_ms: codingTimeMs,
 total_time_ms: reasoningTimeMs + codingTimeMs,
 degraded: false,
 },
 };
}
export async function handleRequest(prompt, forceHybrid = false) {
 const route = forceHybrid ? "hybrid" : classifyComplexity(prompt);
 if (route === "hybrid") {
 try {
 return await executeHybridPipeline(prompt);
 } catch (error) {
 console.error(
 JSON.stringify({ event: "hybrid_pipeline_failed", error: error.message })
 );
 const fallbackResult = await directGeneration(prompt);
 return {
 ...fallbackResult,
 metadata: {
 ...fallbackResult.metadata,
 degraded: true,
 degraded_reason: error.message,
 },
 };
 }
 }
 return await directGeneration(prompt);
}

The classifyComplexity function uses a keyword hit count combined with prompt word count as a heuristic. Two or more keyword matches trigger the hybrid route. A single keyword match paired with a longer prompt (more than 15 words by default) also triggers it. This is deliberately simple and tunable. The fallback in handleRequest catches R1 failures and reroutes to Sonnet directly, attaching a degraded flag and reason to the response metadata so callers can distinguish degraded-mode responses from normal ones. Note that if the Sonnet call also fails, the error propagates to the caller -- only the R1 reasoning phase is covered by the fallback.

Express API Endpoint

// server.js
import "dotenv/config";
import express from "express";
import cors from "cors";
import { handleRequest } from "./services/router.js";
// Fail fast: validate required environment variables before accepting traffic
const REQUIRED_ENV = ["DEEPSEEK_API_KEY", "ANTHROPIC_API_KEY"];
for (const key of REQUIRED_ENV) {
 if (!process.env[key]) {
 console.error(`Fatal: missing required environment variable ${key}`);
 process.exit(1);
 }
}
// Validate ALLOWED_ORIGIN is not a wildcard
const ALLOWED_ORIGIN = process.env.ALLOWED_ORIGIN || "http://localhost:5173";
if (ALLOWED_ORIGIN === "*") {
 console.error("Fatal: ALLOWED_ORIGIN must not be '*' — set a specific origin URL");
 process.exit(1);
}
const app = express();
app.use(cors({ origin: ALLOWED_ORIGIN }));
app.use(express.json());
const MAX_PROMPT_LENGTH = 4000;
app.post("/api/generate", async (req, res) => {
 const { prompt, forceHybrid } = req.body;
 if (!prompt || typeof prompt !== "string") {
 return res.status(400).json({ error: "A valid prompt string is required" });
 }
 if (prompt.length > MAX_PROMPT_LENGTH) {
 return res.status(400).json({ error: `Prompt exceeds maximum length of ${MAX_PROMPT_LENGTH} characters.` });
 }
 // Explicit boolean validation — reject non-boolean to prevent cost abuse
 if (forceHybrid !== undefined && typeof forceHybrid !== "boolean") {
 return res.status(400).json({ error: "forceHybrid must be a boolean if provided" });
 }
 try {
 const result = await handleRequest(prompt, forceHybrid ?? false);
 res.json({
 result: result.generatedCode,
 reasoningPlan: result.reasoningPlan,
 metadata: result.metadata,
 });
 } catch (error) {
 console.error(
 JSON.stringify({ event: "generation_failed", error: error.message, stack: error.stack })
 );
 res.status(500).json({ error: "Generation failed. Check server logs." });
 }
});
const PORT = parseInt(process.env.PORT ?? "3001", 10);
app.listen(PORT, () =>
 console.log(JSON.stringify({ event: "server_started", port: PORT }))
);

The server validates that required API keys are present at startup, exiting immediately with a clear error message if any are missing. The CORS configuration restricts cross-origin access to the ALLOWED_ORIGIN specified in your .env file -- set this to your frontend's URL. A wildcard "*" origin is explicitly rejected at startup. For production, add rate limiting (e.g., npm install express-rate-limit and apply rateLimit({ windowMs: 60000, max: 10 }) to the generate route) to prevent cost exhaustion from automated or abusive requests. The endpoint validates forceHybrid as a strict boolean, rejecting non-boolean values to prevent cost abuse via forced hybrid routing. The response includes both the generated code and the reasoning plan (when available), along with timing metadata for observability.

Adding a React Frontend

UI for Submitting Prompts and Viewing Results

Bootstrap the React app with Vite:

npm create vite@latest hybrid-ai-frontend -- --template react
cd hybrid-ai-frontend
npm install

Replace src/App.jsx with the component below, then start the dev server with npm run dev. The app will be available at http://localhost:5173.

// src/App.jsx
import { useState } from "react";
// Configure via VITE_API_URL in frontend .env
const API_BASE = import.meta.env.VITE_API_URL ?? "http://localhost:3001";
export default function App() {
 const [prompt, setPrompt] = useState("");
 const [forceHybrid, setForceHybrid] = useState(false);
 const [loading, setLoading] = useState(false);
 const [result, setResult] = useState(null);
 const [error, setError] = useState(null);
 const handleSubmit = async () => {
 setLoading(true);
 setError(null);
 setResult(null);
 try {
 const response = await fetch(`${API_BASE}/api/generate`, {
 method: "POST",
 headers: { "Content-Type": "application/json" },
 body: JSON.stringify({ prompt, forceHybrid }),
 });
 if (!response.ok) {
 // Avoid surfacing raw server error details to the UI
 console.error("API error:", await response.text());
 throw new Error("Request failed");
 }
 const data = await response.json();
 setResult(data);
 } catch (err) {
 console.error("Submit error:", err);
 // Fixed user-facing message — do not expose err.message
 setError("Generation failed. Please try again.");
 } finally {
 setLoading(false);
 }
 };
 return (
 <div style={{ maxWidth: 960, margin: "2rem auto", fontFamily: "system-ui" }}><h1>Hybrid AI Workflow</h1><textarea
 rows={5}
 style={{ width: "100%", fontSize: "1rem", padding: "0.5rem" }}
 placeholder="Describe what you want to build..."
 value={prompt}
 onChange={(e) => setPrompt(e.target.value)}
 /><div style={{ margin: "1rem 0" }}><label><input
 type="checkbox"
 checked={forceHybrid}
 onChange={(e) => setForceHybrid(e.target.checked)}
 />{" "} Force Hybrid Mode
</label><button
 onClick={handleSubmit}
 disabled={loading || !prompt.trim()}
 style={{ marginLeft: "1rem", padding: "0.5rem 1.5rem" }}
 >{loading ? "Generating..." : "Generate"}</button></div>{error && <p style={{ color: "red" }}>{error}</p>}{result && (
 <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr", gap: "1rem" }}><div><h2>Reasoning Plan</h2><pre style={{ background: "#f4f4f4", padding: "1rem", overflow: "auto", maxHeight: 400 }}>{result.reasoningPlan
 ? JSON.stringify(result.reasoningPlan, null, 2)
 : "Direct mode — no reasoning phase used."}</pre></div><div><h2>Generated Code</h2><pre style={{ background: "#1e1e1e", color: "#d4d4d4", padding: "1rem", overflow: "auto", maxHeight: 400 }}>{result.result}</pre></div><div style={{ gridColumn: "1 / -1", background: "#eef", padding: "1rem" }}><h3>Metadata</h3><p>Model: {result.metadata.model_used}</p><p>Reasoning: {result.metadata.reasoning_time_ms}ms</p><p>Coding: {result.metadata.coding_time_ms}ms</p><p>Total: {result.metadata.total_time_ms}ms</p>{result.metadata.degraded && (
 <p style={{ color: "orange" }}> ⚠ Degraded mode: {result.metadata.degraded_reason}</p>
 )}</div></div>
 )}</div>
 );
}

The dual-panel layout displays the reasoning plan on the left and generated code on the right, making the hybrid pipeline's two-phase nature immediately visible. The metadata bar at the bottom surfaces timing data so developers can observe the latency characteristics of each phase directly. The API URL is configurable via the VITE_API_URL environment variable, defaulting to http://localhost:3001 for local development.

Optimizing Cost and Latency

Cost Optimization Strategies for Multi-Model Workflows

The pricing differential between models is where ai cost optimization in a hybrid workflow pays off most. DeepSeek-R1 input tokens cost roughly $0.55 per million versus Sonnet's $3.00 per million. On the output side, the gap widens further: $2.19 versus $15.00 per million tokens. For workflows where the reasoning phase produces 1,000 output tokens of planning before Sonnet generates 2,000 tokens of code, the reasoning phase costs a fraction of what it would cost to have Sonnet reason its way through the same problem.

Two additional strategies reduce costs further. First, caching reasoning outputs for semantically similar prompts avoids redundant R1 calls entirely. A simple hash of normalized prompt text can serve as a cache key. Second, truncating verbose R1 output before passing it to Sonnet reduces input token consumption on the more expensive model. Strip the reasoning chain down to its structural conclusions, discarding intermediate deliberation.

Balancing Latency Across Multiple Models

The sequential nature of the pipeline means latencies add up. Typical ranges are 3 to 8 seconds for R1 reasoning and 2 to 5 seconds for Sonnet coding, producing a total hybrid latency of 5 to 13 seconds. A single Sonnet call for the same task runs 2 to 5 seconds but omits edge cases and produces architecturally flat solutions on complex prompts.

When a request contains multiple independent reasoning subtasks, you can parallelize them with concurrent R1 calls before merging results for Sonnet.

Setting aggressive timeouts (the 30-second timeout in the DeepSeek client above) with automatic fallback to single-model generation prevents the worst-case latency scenarios from degrading the user experience.

Production Considerations

Error Handling and Fallback Strategies

The router already implements the primary fallback: if the DeepSeek-R1 call fails or times out, the pipeline degrades gracefully to a direct Sonnet call with an enhanced system prompt. The response metadata includes a degraded flag and reason so monitoring systems and upstream callers can distinguish degraded-mode responses from normal ones. For production deployments, add retry logic with exponential backoff for each API independently. A reasonable starting point is three retries with delays of 1, 2, and 4 seconds. Apply longer backoff periods to rate limit errors (HTTP 429).

Monitoring and Observability

Log a structured JSON entry for every request containing: the route taken (hybrid or direct), tokens consumed per model, latency per phase, and estimated cost. This data feeds directly into cost dashboards and performance monitoring. Structured JSON logging makes aggregation across tools like Datadog, CloudWatch, or ELK straightforward. Track the ratio of hybrid to direct requests over time to validate and tune the complexity heuristic.

Implementation Checklist

Setup

1. Obtain and configure API keys for DeepSeek and Anthropic.
2. Create .gitignore with .env listed before initializing version control.
3. Set up the Node.js project with Express, Anthropic SDK, dotenv, and cors.

Backend

4. Implement the DeepSeek-R1 reasoning client with structured JSON output parsing.
5. Implement the Claude Sonnet coding client with reasoning plan context injection.
6. Build the complexity router with keyword-based heuristic classification.
7. Create the Express orchestration endpoint with prompt length validation, CORS restrictions, and metadata tracking in the response.

Frontend

8. Bootstrap the React frontend with Vite and add the dual-panel output display for reasoning and code.

Production Hardening

9. Add cost estimation logging based on token counts and per-model pricing.
10. Implement fallback and timeout handling for R1 failures.
11. Test with at least three prompt types: simple code generation, complex architectural design, and ambiguous requirements.

Next Steps

To extend this workflow, start by adding a third model for automated code review or test generation. Implement streaming responses for both phases to reduce perceived latency. If you run this in a team setting, integrate the orchestration layer into your CI/CD pipeline for automated code generation on pull requests.