Bridging LiteLLM agents to Claude Code on your local machine — async task delegation pattern

[abhinaykrupa]

Hey LiteLLM community!

For anyone building agents with LiteLLM that need to execute code or run tasks on the user's actual machine, here's a pattern that might be useful.

What it is

cowork-to-code-bridge — an async file-based bridge that lets LiteLLM-based agents delegate complex tasks to Claude Code on the local machine, then poll for results.

This complements LiteLLM's model routing beautifully: you can use LiteLLM to route reasoning/planning tasks across different models, then hand off execution to Claude Code for the parts that need real local machine access.

Pattern

import litellm
from cowork_to_code_bridge.client import call_remote, queue_task, poll_task_result

def agent_loop(user_request):
    # LiteLLM handles model routing for the planning layer
    plan = litellm.completion(
        model="gpt-4o",  # or claude-3-5-sonnet, gemini, etc.
        messages=[{"role": "user", "content": f"Plan how to: {user_request}"}]
    )
    
    # Bridge handles local execution
    task_id = queue_task(
        f"Execute this plan on the local machine: {plan.choices[0].message.content}",
        idempotency_key=f"task-{hash(user_request)}"
    )
    
    return poll_until_done(task_id)

Why local execution matters

LiteLLM is excellent for model routing, but the execution layer often needs:

• Access to user's local repos and files
• Installed local tools (Docker, specific CLIs)
• Persistent state across operations
• Full shell access without sandbox limitations

Production safety

• Per-operation metrics (api_spend_estimate, memory, CPU)
• Loop detection (circuit-breaker when same tool called 3+ times)
• Graceful cancellation with SIGTERM
• Daily quota tracking
• Auth by HMAC-signed token (no open ports)

Repo: https://github.com/abhinaykrupa/cowork-to-code-bridge

Interested in whether this overlaps with how anyone here is building multi-model agent pipelines — especially the LiteLLM model router → local executor handoff pattern.