Kuroko

Your personal assistant for Microsoft Teams

You on stage. Kuroko handles the rest.

Kuroko answers in Teams as you, keeps a daily record of your Azure DevOps tasks and implements your work items with coding agents on your own computers. Only with what you authorize, and with code checking every step.

Open source (MIT) · Self-hosted · macOS, Windows and Linux · Replies in English or Spanish

A kabuki stage with its striped curtain. On an empty chair sits a laptop, and a small stagehand dressed in black slides a chat bubble onto its screen.

As you, not a botdelegated Microsoft sign-in with PKCE

4 permissionsthe Microsoft Graph minimum, no new scopes

0 retrieswhen sending to Teams: when in doubt, you review

Read-onlydaily activity records never change your tasks

Why 黒子 Kuroko?

In kabuki theatre, kuroko are the stagehands dressed in black who move the props and help the actor in plain sight. By convention, the audience treats them as invisible. Kuroko does the same for you: it answers your messages, keeps your records and moves your work forward behind the scenes, so you stay on stage.

Act 1 · Microsoft Teams

Answers in Teams as you, only with what you authorize

When someone writes to you directly, mentions you in a group or asks in your personal chat, Kuroko reads only the sources open to that conversation, writes with the models you choose (Codex, Claude Code, OpenCode 2 or DeepSeek, in your order, with fallback) and replies as you.

  • Your own identity. Delegated Microsoft sign-in with PKCE and four permissions: User.Read, Chat.Read, ChatMessage.Send and offline_access.
  • Checked in code. References, links and sensitive data are verified before sending. If something can't be verified, nothing is sent and you get a note in your personal chat.
  • Sent once. A send is never retried: an uncertain one is left for your review.
  • Observation mode. Start with drafts that are never sent. Rate them, keep good ones as examples, improve one with your context and send it by hand, then turn sending on when you trust it.
  • Cards in your style. Every message is a card with a colored stripe and a band saying it was written with AI. Choose its text, position, colors and sizes, or sign it “Message generated by Kuroko” with the app's icon and a link back here.
Settings, message style in Teams: the band is signed as Kuroko, and the preview card ends with the app's icon and “Message generated by Kuroko”.
The message style in Settings, with a preview of the card. Synthetic data.

Act 2 · Activity records

A daily record of your work, without touching your tasks

Activities saves your existing Azure DevOps tasks by day, on a schedule or when you ask, with verified links, descriptions, their HU and the hours against your daily target. “What did I do yesterday?” is then answered from that record.

  • Read-only. Daily activity runs never create, link or change work items.
  • Activity review. Ask which work no task records: Kuroko compares your commits, pull requests, pipeline runs, releases, Wiki edits and, if you allow it, your Teams messages with your work items, and lists each piece with its verified link and where it could go.
  • Status rounds. Progress, commitments and blockers, read from the work item itself and your own recent Wiki pages.
  • History. Every saved day between two dates, in the app or with kuroko activity history.
Test chat: a review of the last two weeks lists two pieces of work no task records, each with the HU it could go under and its verified link.
An activity review in the test chat. Synthetic data.
Activities on a phone: one saved day with its task, its HU and 3 of 9 hours against the advisory daily target.
A saved day on a phone.

Act 3 · Implementation and workflows

Implements your work items on your own machines

From To-Do or a work item, Implement picks one of your computers, its directories and an installed coding agent (Codex, Claude Code or OpenCode) with its model and effort. HUs, bugs and GitHub epics get a plan of children that you review, edit and confirm before anything is created; tasks and issues go straight to coding.

  • Workflows. A saved recipe per Azure DevOps project: its repositories, the machine and checkouts, the agent and its instructions. A director picks the workflow that fits each item, and a watcher can start runs for items that reach a ready state. The plan review always waits for you.
  • Dependencies and limits. A run waits for its predecessors' pull requests or stacks on their branch, and a workflow can cap how many pull requests it keeps open.
  • Review rounds. When a reviewer rejects a pull request or asks for changes, the agent corrects the same branch, answers each thread and sends it back. Past the workflow's limit, a person decides.
  • A supervisor, if you want one. It reads what the agents did, checks their reports against facts, drafts handover notes and summaries, and proposes the next step for you to confirm.
  • Every session on record. Each agent session keeps its state and times; progress summaries go to Teams only with the text you approved.

Coding runs are autonomous, with full permissions on the computer you choose: that trusted machine and its allowed directories are the boundary.

Act 4 · Knowledge

Knows only what you let it know

Sources are what Kuroko may read: files and whole repositories, exact URLs, Azure DevOps activity and Wiki, your verified notes, the activity record, your own Teams messages and your recent coding-agent sessions. Each one starts disabled, with no audience, and you choose the conversations that may use it.

  • Contexts. The words, sources and instructions of one subject. They narrow and guide; they never authorize.
  • Verified notes and questions. Facts you confirmed, and the questions you configure with their sources. Your ratings guide later answers to the same question, never its facts.
  • Knowledge index. Full-text search over repositories, notes and questions, and search by meaning with an optional embeddings endpoint.
  • The Wiki, credited. Answers link the pages they used and say who documented them.
  • Your organization. Optional work item guides, norms and conventions, kept in your own account. They inform answers and agents and grant nothing.

Act 5 · Machines

One account, on all your computers

Connect the computers you own, on macOS, Windows or Linux: copy one command from your portal, run it and choose Trust this machine in the browser. Your account's configuration follows you; folders, credentials and sign-ins stay on each computer.

  • Your private portal. The same interface from any device, behind your own Cloudflare Access. Only the GitHub owner you configure gets in.
  • In your pocket. Add the portal to your iPhone's home screen: its own icon, a floating tab bar, light or dark.
  • A role for each. One machine answers Teams; any trusted one can run coding agents in the directories you allow.
  • Updates from the app. Checked against the release's SHA-256. Unattended updates are per computer and off until you turn them on.
Home in the browser: Kuroko running in observation mode, the recent outcomes, the workflow runs waiting for you and the setup.
Home, in your browser. Synthetic data.
The same Home on a phone, with the floating tab bar.
The portal on a phone.

Act 6 · Security and privacy

Your secrets stay behind the curtain

A private installation you control: your accounts, your credentials, your computers. Models propose; code decides what can be read, cited and sent.

  • Credentials in the system store. macOS Keychain, Windows Credential Manager or private profile files on Linux. Stored Microsoft tokens are encrypted.
  • Variables by reference. Your account's variables are encrypted. Agents find them by name and description but never see a value: they use them through launchers and destinations you approve, and the host passes the value itself.
  • Model decisions grant nothing. Code checks audiences, paths, URLs and limits. Answers are written without tools, with known secrets redacted. No new Graph scopes, ever.
  • You confirm what leaves. Sending to Teams, granting access and implementation need your confirmation.
  • Optional cloud store. Keep your account's records on Cloudflare, sealed on your computer with a key Cloudflare never receives.

You configure Cloudflare Access, TLS, SSH keys and a firewall for your host. Profiles share your OS account, and coding agents are not isolated from it. The security policy tracks these limits.

Backstage

For agents and power users

Everything the app does is also a command and a tool, so your own agents can work the stage too.

The kuroko CLI

Every operation from the terminal, with stable JSON output (--json) and every command described in kuroko help.

An MCP server

kuroko mcp serves the app's tools to Claude Code, Codex or any MCP client; your portal also serves them at /mcp for agents with nothing installed. Actions outside the app ask you first.

A built-in skill

The operating manual for agents ships inside the binary: kuroko skill show.

# what is running, as JSON
kuroko status --json
# the activity record of a range of days
kuroko activity history 2026-10-01..2026-10-15
# add the MCP server to Claude Code
claude mcp add --scope user kuroko -- kuroko mcp

Install

Kuroko (formerly Personal Teams Assistant) is one package, kuroko on crates.io, that installs the host with its web interface and the kuroko CLI. Self-hosted: you bring the accounts, credentials and hosting, and your profile carries over between versions.

One command

Copy it from your portal (Settings › Machines › Connect this computer). It checks the release archive's SHA-256, installs for your user and starts the host at login. Without --origin it only installs.

# macOS and Linux
curl --proto '=https' --tlsv1.2 -fsSL \
  https://github.com/elvisbrevi/kuroko/releases/latest/download/install.sh \
  | sh -s -- --origin https://your-portal.example
# Windows: install.ps1 from the same release, in PowerShell

With Cargo

cargo binstall downloads the prebuilt release in seconds; cargo install compiles it. The same build on macOS, Windows and Linux.

cargo binstall kuroko
# or compiled here
cargo install kuroko --locked
kuroko-host  # opens it in your browser

On a server

The same install, run in the foreground as a service and operated with kuroko or the portal.

kuroko-host --start
# fits a systemd service
  1. 1

    Configure

    Save your provider credentials, choose the reply language and model order, and register your own Entra app. Home tells you what's missing.

    kuroko status
  2. 2

    Connect

    Sign in with your Microsoft account and give the host a stable HTTPS address, for example your own Cloudflare Tunnel.

    kuroko auth microsoft login
  3. 3

    Observe

    Authorize your sources, start the assistant and review its drafts without sending anything.

    kuroko start
  4. 4

    Go live

    Once you trust the drafts, turn off observation mode.

    kuroko mode active

To receive messages, the machine that answers Teams must be on and reachable at a public HTTPS address. Don't run two active instances for the same account.

Start in observation mode.

Nothing is sent until you decide. Kuroko waits in the wings.

cargo install kuroko --locked