Andrew Ng ships Open CoWorker desktop AI agent

Notifications You must be signed in to change notification settings

Fork 1.5k

Star 14.7k

BranchesTags

Open more actions menu

Folders and files

NameName

Last commit message

Last commit date

Latest commit

History

373 Commits

373 Commits

.github/workflows

.github/workflows

aisuite-js

aisuite-js

aisuite

aisuite

cli/py/aisuite-code-cli

cli/py/aisuite-code-cli

docs

docs

examples

examples

guides

guides

platform

platform

scripts

scripts

tests

tests

viewer-ui

viewer-ui

.env.sample

.env.sample

.git-blame-ignore-revs

.git-blame-ignore-revs

.gitignore

.gitignore

.pre-commit-config.yaml

.pre-commit-config.yaml

CONTRIBUTING.md

CONTRIBUTING.md

LICENSE

LICENSE

README-alternative.md

README-alternative.md

README.md

README.md

poetry.lock

poetry.lock

pyproject.toml

pyproject.toml

Repository files navigation

An AI agent that lives on your desktop, built on aisuite.

OpenCoworker is a desktop AI agent that can not only chat, but also do deep research and carry out tasks for you on your computer. It can read files (with permission) to gain context, read/send messages (slack, email, etc.), and create real deliverables like PDF reports, documents, spreadsheets. It also supports scheduled automations, such as providing you a daily news summary.

Requires bringing your own API key (OpenAI, Anthropic, Google) or run fully local with Ollama. Your data stays on your machine.

⬇ Download for macOS macOS 13+ (Apple Silicon)

⬇ Download for Windows Windows 10/11 (x64)  ·

Quickstart: — install, connect a model, first tasks, automations.

Its source lives in this repository under platform/ — a working reference for building your own agent harness on aisuite.

aisuite

aisuite is a lightweight Python library for building with LLMs, in two layers: a unified Chat Completions API across providers, and an Agents API with tools and toolkits on top. This repo is also home to OpenCoworker, a desktop AI coworker built using aisuite:

┌───────────────────────────────────────────────┐ │ OpenCoworker │ agent harness for doing everyday tasks ├───────────────────────────────────────────────┤ │ Agents API · Toolkits · MCP │ build agents across multiple LLMs ├───────────────────────────────────────────────┤ │ Chat Completions API │ one API across multiple LLM providers ├────────┬───────────┬────────┬────────┬────────┤ │ OpenAI │ Anthropic │ Google │ Ollama │ Others │ └────────┴───────────┴────────┴────────┴────────┘

Chat Completions API — a unified, OpenAI-style interface for OpenAI, Anthropic, Google, Mistral, Hugging Face, AWS, Cohere, Ollama, OpenRouter, and more. Swap providers by changing one string.

Agents API · Toolkits · MCP — give models real Python functions as tools, run multi-turn loops, attach ready-made toolkits (files, git, shell) or any MCP server, and govern it all with tool policies.

OpenCoworker — a desktop AI coworker built using aisuite, shipped as an app for everyday tasks.

Installation

The aisuite library (Python)

Install the base package, or include the SDKs of the providers you plan to use:

pip install aisuite # base package, no provider SDKs pip install 'aisuite[anthropic]' # with a specific provider's SDK pip install 'aisuite[all]' # with all provider SDKs

You'll also need API keys for the providers you call — the Chat Completions quickstart covers key setup and your first calls.

The OpenCoworker app (desktop)

Download the installer and bring your own API key (or run local models with Ollama):

⬇ macOS (Apple Silicon)  ·  ⬇ Windows 10/11 (x64)  ·  OpenCoworker quickstart

Chat Completions — one API across providers

The chat API provides a high-level abstraction for model interactions. It supports all core parameters (temperature, max_tokens, tools, etc.) in a provider-agnostic way, and standardizes request and response structures so you can focus on logic rather than SDK differences.

Model names use the format :; aisuite routes the call to the right provider with the right parameters:

import aisuite as ai client = ai.Client()

models = ["openai:gpt-4o", "anthropic:claude-3-5-sonnet-20240620"]

messages = [ {"role": "system", "content": "Respond in Pirate English."}, {"role": "user", "content": "Tell me a joke."}, ]

for model in models: response = client.chat.completions.create( model=model, messages=messages, temperature=0.75 ) print(response.choices[0].message.content)

→ Quickstart: docs/chat-completions-quickstart.md — install, key setup, local models, and more examples.

Agents — give models real tools

aisuite turns tool calling into a one-liner: pass plain Python functions and it generates the schemas, executes the calls, and feeds results back to the model.

Tool calling with max_turns

def will_it_rain(location: str, time_of_day: str): """Check if it will rain in a location at a given time today.

Args: location (str): Name of the city time_of_day (str): Time of the day in HH:MM format. """ return "YES"

client = ai.Client() response = client.chat.completions.create( model="openai:gpt-4o", messages=[{ "role": "user", "content": "I live in San Francisco. Can you check for weather " "and plan an outdoor picnic for me at 2pm?" }], tools=[will_it_rain], max_turns=2 # Maximum number of back-and-forth tool calls ) print(response.choices[0].message.content)

With max_turns set, aisuite sends your message, executes any tool calls the model requests, returns the results to the model, and repeats until the conversation completes. response.choices[0].intermediate_messages carries the full tool interaction history if you want to continue the conversation.

Prefer full manual control? Omit max_turns and pass OpenAI-format JSON tool specs — aisuite returns the model's tool-call requests and you run the loop yourself. See examples/tool_calling_abstraction.ipynb for both styles.

The Agents API

For longer-running, structured work there is a first-class Agents API: declare an agent once, run it with a Runner, and attach toolkits — prebuilt, sandboxed tool families for files, git, and shell:

import aisuite as ai from aisuite import Agent, Runner

agent = Agent( name="repo-helper", model="anthropic:claude-sonnet-4-6", instructions="You are a careful repo assistant. Use your tools to answer from the code.", tools=[*ai.toolkits.files(root="."), *ai.toolkits.git(root=".")], )

result = Runner.run(agent, "What changed in the last commit? Summarize in 3 bullets.") print(result.final_output)

The Agents API also gives you the pieces a production harness needs:

Tool policies — RequireApprovalPolicy, allow/deny lists, or your own callable deciding which tool calls run.

State stores — persist and resume runs (in-memory, file, or Postgres) and continue conversations across processes.

Artifacts & tracing — capture what an agent produced and every step it took along the way.

MCP tools

aisuite natively supports the Model Context Protocol, so any MCP server's tools can be handed to a model without boilerplate (pip install 'aisuite[mcp]'):

client = ai.Client() response = client.chat.completions.create( model="openai:gpt-4o", messages=[{"role": "user", "content": "List the files in the current directory"}], tools=[{ "type": "mcp", "name": "filesystem", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"] }], max_turns=3 ) print(response.choices[0].message.content)

For reusable connections, security filters, and tool prefixing, use the explicit MCPClient.

→ Quickstart: docs/agents-quickstart.md — manual tool handling, the full Agents API, policies, state stores, and MCP in depth.

Extending aisuite: Adding a Provider

New providers can be added by implementing a lightweight adapter. The system uses a naming convention for discovery:

Element Convention

Module file _provider.py

Class name Provider (capitalized)

Example:

providers/openai_provider.py

class OpenaiProvider(BaseProvider): ...

This convention ensures consistency and enables automatic loading of new integrations.

Contributing

Contributions are welcome. Please review the Contributing Guide and join our Discord for discussions.

License

Released under the MIT License — free for commercial and non-commercial use.

About

Simple, unified interface to multiple Generative AI providers

Resources

Readme

License

MIT license

Contributing

Contributing

Uh oh!

There was an error while loading. Please reload this page.

Activity

Stars

14.7k stars

Watchers

181 watching

Forks

1.5k forks

Report repository

Releases 4

OpenCoworker 0.1.1

Latest

Jun 11, 2026

+ 3 releases

Packages 0

Uh oh!

There was an error while loading. Please reload this page.

Uh oh!

There was an error while loading. Please reload this page.

Contributors

Uh oh!

There was an error while loading. Please reload this page.

Languages

Python 74.9%

TypeScript 18.6%

CSS 3.4%

JavaScript 2.0%

Rust 0.7%

PowerShell 0.2%

Other 0.2%