OpenDuet README

项目的 README,来自 github.com/CopilotKit/OpenDuet。合并为一个 markdown 文件:README.md。

OpenDuet

An open-source proactive agent that gets your work done and keeps you in the loop

Built on OpenBot and CopilotKit · Quick start · Overview · Features and Capabilities · How it works · Contributing

Built on OpenBot License: MIT Status: early development

#3 TypeScript Repository Of The Day on Trendshift

Each agent has a computer of its own. Use it on the web, on mobile, in Slack, or in Microsoft Teams.

Host OpenDuet yourself and choose your own model. Requires a free CopilotKit Intelligence project for threads and memory. Everything that makes it OpenDuet lives in one folder, so copy it and make it your own.

OpenDuet is now available as a UX skin in OpenBot, a more robust version with sign-in, per-Bot permissions and an audit trail, maintained by CopilotKit. This repo stays a community-maintained starter for building your own project.

OpenBot running the OpenDuet skin
OpenBot with the OpenDuet skin, picked under Settings → Skin

Bringing OpenDuet to your company? Talk to us about OpenBot →


https://github.com/user-attachments/assets/f3439f74-855e-4d95-bb5c-713fded3c66e

Setting it up takes a minute: onboarding ends on a checklist of what OpenDuet depends on.

https://github.com/user-attachments/assets/55b74b87-708e-4e69-af1e-16e4071ead95

OpenDuet and OpenBot

OpenDuet runs on OpenBot, CopilotKit's open-source agent platform, and ships inside it as a skin alongside OpenDots and OpenFuse. Pick it there and you get OpenDuet's look, with everything OpenBot does underneath.

If you want to Start here
Try OpenDuet, or make it your own This repo: Quick start
Run it for your team, with sign-in, per-Bot permissions and an audit trail OpenBot, then Settings → Skin → OpenDuet
Have us stand it up inside your company Talk to an engineer

OpenDots, OpenFuse and OpenDuet are community maintained, and issues and pull requests are welcome in each repo. OpenBot is the one the CopilotKit team maintains and ships fixes to.

Overview

OpenDuet does not wait to be asked. It starts your day with a short brief, keeps working on a computer of its own while you step away, and comes back only when something needs you. Before it sends, pays, signs, or deletes anything, it shows you exactly what it is about to do and waits for your answer.

Early. OpenDuet runs today as OpenBot, CopilotKit's open-source, self-hosted agent platform, with OpenDuet's name, Bots and skills on top. It already reads your Gmail and calendar, sorts what needs you from what can wait, and makes the morning brief. Features and Capabilities lists what works today. Expect things to move. Issues and ideas are welcome.

What it does

See Features and Capabilities for what works today.

Five OpenDuet screens on a phone: Chat with the morning brief, Tasks, Make with the pages it made, the side panel listing channels, and a suggested task being swiped right to start it.

Features and Capabilities

Everything below works today when you run this repository.

Capability What it means for you
A computer of its own Keeps working in its own browser, /workspace, and shell while you are away.
Asks before it acts A reviewer checks every action that changes something, and the ones that matter pause for Refuse, Allow once, or Always allow. A message to other people always asks, once, showing who it goes to and what it says. Anything you type while it carries an action out waits its turn and is answered after. Every action is checked against policy and recorded.
Never sees your passwords Logins go through a masked secret box. Saved credentials are encrypted and write-only.
Memory Threads and memory carry over through CopilotKit Intelligence.
Skills Reusable instructions you write once and call with /.
Gmail and Google Calendar Each person connects their own account. OpenDuet reads mail and today's calendar, and sends a reply only after you answer.
Connected apps Governed MCP connectors, including Google Drive and Notion.
Public-web research Search public sources, read selected pages and make a brief with source links after an administrator grants the research tools. Set up a research provider.
Scheduled work Routines: ask it to do something on a schedule and it runs as you.
Make it your own Its name, Bots, channels, model, and skills live in one folder, openbot/examples/openduet.
What needs you, what can wait Sorts new mail into what needs you and what can wait, with a one-line reason for each. Measured on a labelled set in evals/triage.
Morning brief The first time you open Chat each day after your first, it is already there: what needs you and why, what can wait, today's calendar, and anything it could not check, posted once a day however many tabs or devices you open. You can also ask for it any time. Start on a row that needs you hands that email to OpenDuet.
Tasks One tab for what needs you, answered right there, what OpenDuet suggests from its background research, and what it is working on. Its newest suggestion also waits above Chat's composer, with Start and Hide. A suggestion you start stays in view: under Working while OpenDuet works, then Ready for review or Needs input with OpenDuet's next step, opening at its own message. Answer it in Chat, on its card or by deciding its approval, and it goes back to Working until OpenDuet replies. A run that fails says why, with Try again where running it again can help. Check one off and it folds into Resolved.
Setup checklist Onboarding asks you to connect Gmail and Calendar and to turn on notifications, each with Not now, then ends on a list of what OpenDuet depends on: Intelligence, the model key, Google, your Gmail and Calendar, notifications, and the optional extras. Each is Ready, Not checked or Needs setup, from the real answer, with how to fix it. Check again asks Intelligence and the model provider again. Settings → Setup opens it again.
Gets to know you On your first day it speaks first: it greets you, reads your recent mail and this week's calendar, then answers in three short bubbles (who you are, three ways it can help, and an invitation to correct it), with Sounds right and Something's off to tap. With Gmail and Calendar not connected, it promises no mail: it says what it can do now and shows the card to connect them.
Make Ask for a design system, a design, a dashboard, slides, a doc or a web page, or pick one from the + on the Make tab, and OpenDuet makes it. A card in Chat opens it, and Make keeps everything it made as thumbnails you can filter by kind.
Channels Make a channel for a piece of work: a name, an icon in a colour, and what it is for. OpenDuet says hello there and offers three things it could start on, keeps the work there about that purpose, and the tasks it starts there wear the channel's colour. Everything stays your one thread, and the menu lists your channels with Archived folded under them.
Answers in a tap When it asks you to choose, the likely answers appear as replies you can tap.
Light or dark Follows your phone's setting, changing with it, or pick Light or Dark in Settings.
Say it instead Tap the voice button in Chat and say everything you need to do. It is written down and sent as your message. Needs a speech-to-text provider on the server (TRANSCRIPTION_*).

Quick start

You will need Docker, Bun 1.3 or newer, Node (for npx, which runs the CopilotKit CLI), a model key, and a CopilotKit Intelligence project. Intelligence is required: it keeps OpenDuet's threads and memory, and the server will not start without its key. The free Developer plan is enough.

Run every command in this section from the repository root.

git clone https://github.com/CopilotKit/OpenDuet.git
cd OpenDuet
cp .env.example .env
bun install

Sign in and pick an Intelligence project:

npx --yes copilotkit@latest login
npx --yes copilotkit@latest project select
bun openbot/scripts/setup-learning.ts

project select writes the project's key to .env as CPK_INTELLIGENCE_API_KEY, its telemetry ID as CPK_TELEMETRY_ID, and your choice to .copilotkit/project.json. The server reads INTELLIGENCE_API_KEY, not CPK_INTELLIGENCE_API_KEY, so the last command finishes the job. It makes sure the project has an openbot Learning container, creating one if it does not (see Automatic Learning), then copies the key to INTELLIGENCE_API_KEY and sets CPK_INTELLIGENCE_LEARNING_CONTAINER_ID=openbot. It reads .env and .copilotkit/ from the directory it runs in, which is why it runs here and not from openbot/. If .env already has an INTELLIGENCE_API_KEY, it keeps it and only checks that the container exists.

Put your model key in .env. The OpenDuet Bot runs OpenAI's gpt-5.6-terra, set in openbot/examples/openduet/model.yaml, so by default that is:

OPENAI_API_KEY=sk-...

To use another provider or model:

Set these before you start it. Settings → Setup in the app says whether the model key works.

Then start it:

bash scripts/start.sh

and open http://localhost:3010. The script starts Postgres and each Bot's computer in Docker, applies the database migrations, and starts the API server, the routine worker, and the app. It checks that each one answers before it prints the next steps. bash scripts/stop.sh stops the app, the worker, the API server and the Docker services, and removes the Bot computers that belong to this install, the ones with its COMPUTER_NAMESPACE. It does not touch another install's. The database, each Bot's files and its browser profile are Docker volumes, so they stay. Add --keep-computers to leave the Bot computers running.

If port 5432 is already taken on your machine, set POSTGRES_PORT in .env to a free port and change the port in DATABASE_URL to match.

For a shared Bot computer, set OPENBOT_ONE_COMPUTER_EACH=false, leave COMPUTER_SUPERVISOR_URL empty, and point AGENT_COMPUTER_URL at http://localhost:<COMPUTER_PORT> (4100 by default). The API and the agent-computer Compose service must use the same nonempty COMPUTER_TOKEN. Start through bash scripts/start.sh to keep them in agreement; it writes the resolved token into .env so a later direct Bun restart keeps it. If you change the token, rerun the start script and restart any API processes launched manually. For a computer per Bot, keep OPENBOT_ONE_COMPUTER_EACH=true: the supervisor owns those containers and their assigned ports; do not point AGENT_COMPUTER_URL at a remembered random port.

To run a second install beside another on one machine, give it its own COMPOSE_PROJECT_NAME, COMPUTER_NAMESPACE, image tags (COMPUTER_IMAGE and the other *_IMAGE settings), and a value for every *_PORT. Change the addresses built from those ports to match: DATABASE_URL, AGENT_COMPUTER_URL, MANAGED_AGENT_AG_UI_URL, OPENBOT_PUBLIC_URL and TRUSTED_ORIGINS. If both use the same Intelligence project, give it its own DEPLOYMENT_ID too. openbot/docs/configuration.md lists them. Two installs can instead share one computer, if they use the same token.

To diagnose a 401, inspect container names and port mappings with docker ps, then compare COMPUTER_TOKEN by equality without printing either value. The setup checklist authenticates against the provider and checks network-policy delivery; a configured URL alone no longer means Ready. A sleeping computer reads Not checked until it is running and Check again succeeds.

The CopilotKit runtime sends usage telemetry to CopilotKit, tagged OpenDuet. Set COPILOTKIT_TELEMETRY_DISABLED=true or DO_NOT_TRACK=1 to turn it off. What is sent.

Once it is running, try the parts that work today:

Sign-in for a team, and Slack and Teams, are OpenBot's: see openbot/docs. A hosted or deploy guide for OpenDuet is not published yet, and neither is an OpenDuet image, so the Quick start above is the supported way to run it today. The Docker and Helm guides in openbot/docs deploy plain OpenBot from OpenBot's own image, not OpenDuet.

Connect Gmail and Google Calendar

Gmail and Calendar need a Google OAuth client, which an administrator registers once. Each person then connects their own account under Connections. With the default .env you are the administrator. Settings → Setup in the app shows which of these steps is still open and links to each page. openbot/docs/plugins/google-workspace.md has the Google Cloud steps: the two APIs to enable, the consent screen, and the OAuth client.

Connecting needs OPENBOT_PUBLIC_URL, the API's address that Google sends people back to. .env.example sets it to http://localhost:3001, so it has to change if you move SERVER_PORT, and it must be the public address once deployed.

To try it without a Google account, use the fake Google that ships for tests and demos. Setting its URL is not enough on its own. The steps are:

  1. Start the fake Google. It serves an invented inbox and calendar.

    bun openbot/scripts/fake-google/server.ts --port 4900
    
  2. In .env, set OPENDUET_FAKE_GOOGLE_URL=http://127.0.0.1:4900, then start OpenDuet. If it is already running, run bash scripts/stop.sh and bash scripts/start.sh, because the API reads .env only when it starts.

  3. Open /admin/plugins/google-workspace. Turn on Enable for this deployment, open OAuth client and paste any client ID and secret (the fake accepts anything), then press Refresh tools.

  4. Grant the connector's tools to the OpenDuet Bot at /admin/plugins/google-workspace/bots/openduet.

  5. Open /connections/google-workspace and press Connect. The fake consents at once, as [email protected], and sends you straight back.

OPENBOT_PUBLIC_URL has to match the API's port, because the fake sends you back through it. curl http://127.0.0.1:4900/__fake/sent shows anything OpenDuet sent. The variable is ignored when NODE_ENV=production. To switch to real Google, remove it, restart, and connect again: the stored sign-in belongs to the fake.

Search the public web

The OpenDuet Bot ships with a public-web research skill. Set up a research provider to let it find sources and read pages without using its browser. The catalogue includes Parallel, Exa and Firecrawl. An administrator enables a connector and grants its search and fetch tools after reviewing the guide's controls and data-sharing risks.

Then try /research-public-web with a request such as “Compare three public project-management tools for a small team, check their current pricing, and make a brief with source links.”

Make it your own

OpenDuet is meant to be copied. Everything that makes it OpenDuet rather than OpenBot is in openbot/examples/openduet:

File What it decides
brand.yaml The product's name, everywhere in the app.
agents.yaml The Bots, their instructions, and which skills each one holds.
channels.yaml The conversations people see, and which Bots answer in each.
model.yaml The model provider and default model.
skills.yaml Instructions anyone can call with /, and the tools each one needs.

Copy the folder, change it, and point TENANT_PACKAGE_DIR in .env at your copy (relative to openbot/server). OpenBot's code underneath stays as it is in openbot/, so OpenBot's fixes can still be brought in.

What is in this repository

Path What it is
openbot/ The platform OpenDuet runs on: OpenBot's server, app, worker, each Bot's computer, Docker and Helm files.
openbot/examples/openduet OpenDuet's tenant package: its name, Bots, channels, model and skills.
scripts/ start.sh and stop.sh, which run OpenBot's scripts with this repository's .env.
docs/ What OpenDuet sends as telemetry, and how to turn it off. OpenBot's own documentation is in openbot/docs.
assets/ The banner.

Built on OpenBot

OpenBot

OpenDuet is built on top of OpenBot, CopilotKit's open-source, self-hosted agent platform. OpenBot provides the server, the app, each Bot's computer, the approval boundary, the audit trail, sign-in, and the Slack and Teams channels. OpenDuet adds the morning brief, Tasks, Make and its own Bots and skills on top; its name, Bots and skills live in one folder, openbot/examples/openduet. To build a different assistant on the same foundation, start from OpenBot, or read more at copilotkit.ai/openbot.

How it works

Everything below works in this repository today.

You: web · Slack / Microsoft Teams
        │                             ▲
        │ asks, answers, approvals    │ morning brief, "this needs you"
        ▼                             │
OpenDuet server   (OpenBot: Hono + CopilotKit runtime)
  ├── triage          what needs you / what can wait
  ├── approvals       Allow once · Always allow · Refuse
  └── gateway         policy → audit record → act
        │ AG-UI
        ▼
Agent   (any AG-UI agent, on a framework or hand-written)
        │ every tool call comes back through the gateway
        ▼
Its own computer   Chromium · /workspace · shell

CopilotKit Intelligence   threads and memory
PostgreSQL + pgvector     policy, approvals, audit, encrypted credentials
MCP connectors            Google Drive, Notion, and more through Composio

Channels. You reach OpenDuet where you already are: the web app, Slack, or Microsoft Teams, all of which OpenBot supports today.

Server. OpenBot's server hosts the CopilotKit runtime and sends each turn to the agent over AG-UI. OpenDuet adds two pieces in front of it: a triage step that decides what needs you and what can wait, and a morning brief built from it. Both build on OpenBot's routines, which give an agent scheduled turns that run as you.

Agent. Any endpoint that speaks AG-UI can be the agent, whether it is built with LangGraph, Mastra, CrewAI, Pydantic AI, Google ADK, or written by hand. OpenDuet is not tied to one framework or one model.

Its own computer. Each agent gets a container of its own, with Chromium, a /workspace volume, a browser profile, and a shell. That is where it keeps working while you step away. When it hits a login wall or a two-factor prompt, it asks for help and you can take the wheel.

Approvals. Every action the agent takes goes through one gateway. The gateway checks the action against your policy, writes an audit record, and only then acts. Actions set to ask pause and show you the exact action and the rule that asked, with Allow once, Always allow, and Refuse. Deny rules refuse an action outright. OpenDuet's defaults will ask before anything that sends, pays, signs, or deletes.

Passwords and credentials. When a site needs a secret, the agent asks for it through a masked box. The value goes to the site; the transcript records only that a secret was requested. Credentials you store are encrypted at rest, write-only, never returned by an API, and redacted from audit events.

What leaves. OpenBot treats any tool it cannot positively classify as a read as a write, and redacts secrets from its audit trail. A message to other people always asks first, showing who it goes to and what it says.

Memory. Threads and memory live in CopilotKit Intelligence, so conversations survive restarts and what it has learned about you carries over. You can see what it remembers about you, and tell it facts directly.

Skills and connectors. Skills are instructions you write once and call with /. Connected apps are governed MCP servers: Google Drive and Notion ship in OpenBot's catalogue, and Composio brokers more. A connector is granted to an agent before it can be used.

Contributing

OpenDuet is early, so please open an issue before starting substantial work. Much of the foundation lives in OpenBot: changes to the computer, the gateway, approvals, credentials, or connectors usually belong there.

About

OpenDuet was built by CopilotKit and is community maintained. CopilotKit is the team behind OpenBot and the AG-UI protocol.

It is CopilotKit's open-source take on the proactive-agent category: assistants that reach out first, such as Claude Duet. OpenDuet is an independent project and is not affiliated with or endorsed by Anthropic.

Rolling it out at your company? Talk to a CopilotKit engineer.

License

MIT © CopilotKit

OpenDuet (CopilotKit/OpenDuet)

正在搜索数据库…

这是什么?OpenDuet 是一个开源、可自托管的主动式 AI 智能体。它会在你新一天开始时给你一份晨间简报,在你离开时在自己的电脑上处理任务,只有在需要你做决定时才会打扰你。
这是一个聊天机器人应用,还是我必须自己托管的完整智能体平台?它是一个可自托管的智能体平台,不是托管的 SaaS 聊天机器人:它以 OpenBot(CopilotKit 的开源智能体平台)运行,并叠加了 OpenDuet 的品牌标识、Bots 和技能。你可以通过网页应用、Slack 或 Microsoft Teams 使用它。
我要怎么让它运行起来?在仓库根目录下,登录并选择一个 CopilotKit Intelligence 项目(这会将 API 密钥写入 .env),在 .env 中填入你的模型密钥,然后用 Docker 和 Bun 启动。运行 CopilotKit CLI 需要用到 npx,因此还需要安装 Node。
我需要 CopilotKit 账户或 OpenAI/Anthropic 密钥吗?两者都需要:必须有一个 CopilotKit Intelligence 项目(免费的 Developer 套餐就够用,但没有该项目的密钥,服务器就无法启动);默认需要 OpenAI 密钥,如果你切换到其他提供商,则需要 Anthropic 密钥。
这个项目已经完成并可用于生产环境了吗?没有——项目明确处于早期阶段且仍在积极开发中,所以目前列为可用的功能仍可能发生变化。
我到底可以在哪里和我的智能体对话?你可以在网页应用、Slack 或 Microsoft Teams 中与它交流;每个智能体还会有自己的容器,内含真实的浏览器、文件和 shell,让它在你离开时继续工作。
智能体会看到我的密码吗?不会——需要登录时,你在带掩码的输入框中输入密码,它会直接传递给网站;密码不会出现在智能体读取的对话中,保存的凭据会加密存储,且仅可写入、不可读取。
“晨间简报”具体包含什么内容?你每天第一次打开 Chat 时,它会显示哪些事项需要你处理及原因、哪些可以稍后再说、今天的日历,以及它无法核实的内容。无论你打开了多少台设备,每天只推送一次。
它如何判断哪些事情需要我关注、哪些可以稍后处理?一个分类步骤会扫描你的邮件、日历和 Slack,把事项分为“需要你处理”和“可以稍后”两类,并为每项附上一行理由。这种分类的质量会与一个带标签的评测集(evals/triage)进行对比衡量。
它可以连接哪些第三方应用?可连接的应用是受管控的 MCP 连接器:内置 Google Drive 和 Notion,Composio 可以提供更多连接。每个连接器在使用前都必须明确授权给某个智能体。
我能否为它重新品牌化,或基于同一基础构建另一个助手?可以。所有构成 OpenDuet 的内容(名称、Bots、渠道、模型和技能)都位于同一个文件夹(openbot/examples/openduet)中,因此你可以复制该文件夹,或从 OpenBot 重新开始,来构建其他助手。
有哪些类似的项目?brigade, hive, claude-code, ruflo, evenfire, turnstone, AutoGPT, OpenDots
大小
163.6 MB
星标
2.1K
更新
提交Nov 14
时长
28天
提交 · 90 天