corgi
Use casesDocsChangelog
Get started

Task-first agent operations

Turn messy requests
into approved agent work.

Corgi is the task orchestration layer for small teams using coding agents. Submit a task, review the proposed jobs, then let your own runtimes execute with status, artifacts, and Lark updates in one workspace.

Start with a taskTalk to sales
Corgi / Task orchestration
Workspace
Tasks
Agents
Runtimes
Job Types
Lark
3 runtimes online

Claude Code, Codex, and OpenCode are ready on your machines.

Natural language task

Ship workspace invitation links

Let admins create reusable invite links with expiry and max-use limits. Notify the team in Lark when setup is ready.

Awaiting approval
Design invite-link schema
Planning Agent
Proposed
Implement backend + migrations
Coding Agent
Blocked until approved
Review auth and permission gates
Security Agent
Proposed
Send Lark completion summary
Lark Agent
Proposed
Human approval gate

Corgi proposes agents, job types, dependencies, and deliverables before any runtime starts execution.

New job type1
Generated agents2
Required resourcesrepo:web

TASKS

A task becomes a reviewed execution plan

Users describe the outcome in plain language. The orchestrator runs on your daemon, decomposes the work into jobs, and brings the plan back for human approval before anything executes.

Task

Natural language request
Creator + workspace context

Orchestrator

Matches job types
Assigns agents and resources

Approval

Review every job
Edit agents before execution

Execution

Runs on your runtimes
Artifacts and Lark updates

TASKS

Natural-language intake

Create tasks from the web app or by mentioning the Lark bot. Every task keeps its creator, workspace, and notification channel attached.

APPROVAL

Review every proposed job

Rename jobs, adjust descriptions, swap assigned agents, and inspect what deliverables each job must produce before approving.

JOB TYPES

Built-in and workspace templates

Global templates stay read-only. Team-specific templates live in the workspace and evolve as the orchestrator discovers new patterns.

RUNTIMES

Runtime-aware dispatch

Each runtime is a machine plus provider. Jobs prefer the agent's best executor and can fall back only when allowed.

Schema-checked proposals

The CLI validates proposed jobs against the Job Type schema before sending them back to Corgi for approval.

Generated agents become reusable

When the orchestrator proposes a new agent persona, approval creates a durable workspace agent that can be reused later.

Online/offline handling

Disconnected runtimes pause tasks instead of hiding failures. Humans can fix the machine and restart from the failed job.

Workflow

From request to artifact
with a human checkpoint.

01

Sign up & create your workspace

Create a workspace, invite members, and connect the places where tasks start: the web app and, when configured, Lark.

02

Connect runtimes

Install the CLI on a machine you control. The daemon discovers supported executors and registers them as workspace runtimes.

03

Approve the plan

The orchestrator decomposes the task into jobs. Review the proposed agents, job types, dependencies, and deliverables before work begins.

04

Track execution

Jobs run in order, artifacts accumulate, blockers ask humans for input, and completion summaries arrive in web and Lark.

Get startedRead the docs

Runtime and Lark control

Corgi coordinates.
Your tools execute.

The server never calls an LLM directly. Orchestration and job execution happen through connected runtimes, while Lark keeps the creator in the loop when tasks finish, fail, pause, or need input.

Talk to sales

Local credentials stay local

Executors use the credentials already configured on the runtime machine. Corgi does not store model provider API keys.

Explicit permission model

Members can manage their own runtimes and tasks. Admins manage invitations, roles, Lark, and workspace-level configuration.

Lark as a first-class channel

Mention the bot to create tasks. Blocked jobs ask questions in Lark and route the reply back into the job context.

Agents are durable teammates

Generated agents are saved to the roster with instructions, executor preferences, and chat history for future work.

FAQ

Questions & answers.

Corgi manages tasks, proposed jobs, approvals, agents, runtimes, artifacts, and notifications. The actual LLM execution happens on runtimes you connect.

Not before approval. The orchestrator proposes the execution plan, and a human approves it in the web app before jobs are dispatched.

Direct coding agents are good at one session. Corgi adds the operating layer around them: task intake, decomposition, approvals, runtime dispatch, artifacts, blockers, and team notifications.

On the runtime machines you connect. Code jobs can use per-runtime repo clones and per-task worktrees so separate tasks do not trample each other.

The job moves to blocked, asks a human-readable question, and notifies the creator in web and Lark. The reply becomes context and the job resumes.

Yes. A workspace can bind a Lark bot. Mentions create tasks, terminal states send summaries, and blocked jobs can receive replies from the original thread.

corgi

Project management for human + agent teams, built for the future of work.

Get started

Product

  • Features
  • How it Works
  • Use cases
  • Changelog

Resources

  • Documentation
  • X (Twitter)
  • Discord

Company

  • About
  • Contact Sales

© 2026 Corgi. All rights reserved.

corgi