Covo Python SDK

Connect the Python agent you already have to a shared Covo session. Your teammates open one link, watch the same run live (model calls, tool calls, results, files, errors), and exactly one person at a time holds control: new instructions, pause/resume, interrupt, approve/reject, hand over control.

The agent keeps running on your machine or server. Your LLM keys, files and tools never leave it; only the events you share reach Covo.

Türkçe tam rehber: Covo panelinde /integrate.

Install

pip install "covo-sdk[openai]"

Python 3.11+, asyncio. The openai extra is only needed if you use instrument() with the OpenAI Python client; any OpenAI-compatible endpoint works (OpenAI, OpenRouter, DeepSeek, Ollama, vLLM, ...).

Three lines of integration

from openai import AsyncOpenAI
from covo_sdk import CovoOwner, instrument, tool

llm = instrument(AsyncOpenAI())            # 1. every model call is shared automatically

@tool(approve=True)                         # 2. tool calls are shared; this one needs approval
async def write_file(path: str, content: str) -> str:
    open(path, "w").write(content)
    return "saved"

async def run(ctx) -> str:                  # 3. your existing agent loop, unchanged
    completion = await llm.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{"role": "user", "content": ctx.instruction}],
    )
    return completion.choices[0].message.content

Start it from your terminal; Covo creates the shared session and prints the link:

import asyncio

async def main():
    owner = await CovoOwner.login(url="https://covo.example.com", name="Ulaş")
    client = await owner.connect(
        run=run, name="Research agent",
        capabilities=["instruct", "pause", "resume", "interrupt", "approval"],
    )
    print("Share with your team:", client.share_url)
    print("Private owner code (do not share):", await owner.browser_code())
    await client.start("Read README.md and propose a plan.")
    await client.wait()

asyncio.run(main())

What the SDK does for you

Manual control for raw HTTP callers:

from covo_sdk import model_span

async with model_span(model, messages) as span:
    payload = await http.post(url, json=request)
    span.result(payload["choices"][0]["message"], tokens=payload["usage"]["total_tokens"])

Share a Claude Code session without writing code

covo --url https://covo.example.com --name "Ulaş" claude-code install

Registers Claude Code hooks. Every new Claude Code session prints a Covo share link; teammates watch tool calls, results and the final answer live, and the controller approves or rejects gated tools (default: Write, Edit, MultiEdit, NotebookEdit, Bash) from Covo. Watch-and-approve only: Covo cannot instruct, pause or interrupt Claude Code, and once control is handed to a teammate the owner's own terminal is blocked from new prompts until it returns. macOS/Linux.

Control model

• One controller per session, enforced server-side. Terminal and browser commands go through the same check; handing over control also locks out the owner's own terminal.
• Interrupt cancels the running asyncio task and waits for cleanup before the replacement run starts. Do not swallow CancelledError; avoid detached threads.
• Declare only the capabilities your agent honors. Unsupported controls are disabled in the UI.
• Credentials live in .covo/ with owner-only permissions. Add .covo/ to .gitignore. Share only the session link.

CLI

covo --version
covo code                     # new private owner code for the browser
covo state <session-id>
covo command <session-id> pause
covo command <session-id> interrupt --text "Stop, use PostgreSQL instead."

Limits

Alpha. Python 3.11+ async agents only. The SDK must be wired into the agent before the run starts; it cannot attach to an already-running process. No automatic resume after a crash: Covo marks the old run failed and waits for a new instruction. Anyone with a session link can watch, so deploy Covo for a trusted team.