Woobe 发布 API 优先的 Agent 控制面与运行时

Build, deploy and operate AI agents like production software.

Woobe is an API-first, source-available control plane and runtime for building and operating Agents and Agent Networks in production. Version prompts, models, tools and knowledge; validate changes through controlled environments; publish immutable releases; execute through a production runtime; and trace exactly what happened.

Woobe sits between your application and the AI execution layer so your product does not have to become its own agent platform.

Pre-1.0: Woobe remains pre-stable. Public APIs and deployment contracts may evolve between minor versions; review release and upgrade notes before updating.

Key Capabilities

• Agents as Versioned Software — Manage prompts, model configuration, tools, knowledge, output contracts and runtime configuration as controlled artifacts instead of mutable production state.
• Immutable Releases & Rollback — Develop freely, validate in Staging, publish immutable Agent and Network Releases, and restore previous working versions without reconstructing historical configuration.
• Agent Networks — Compose multiple Agents into first-class Networks with their own versions, releases, Sessions, Runs and Traces.
• Production Runtime — Execute Agents and Networks through synchronous, streaming and asynchronous runtime paths under the same Run model.
• Tracing & Observability — Record execution events, release provenance, versions, usage and runtime evidence for every Run.
• Knowledge / RAG — Organize Project knowledge with Collections and Documents and preserve exact indexed knowledge state through Vector Snapshots.
• Tools & Providers — Connect external capabilities through HTTP and MCP while keeping credentials and execution policy server-side.
• ChatSurface — Publish released Agents and Networks through an independently deployable browser-facing conversational surface.
• Self-Hostable Core — Run Woobe Core on your own infrastructure.

From Draft to Production

Configure
   ↓
Development / Draft
   ↓
Validate in Staging
   ↓
Create immutable Release
   ↓
Activate in Production
   ↓
Run · Trace · Observe
   ↓
Rollback when needed

Production execution is release-based. Mutable Draft configuration should never silently change a released workload.

Core Model

Quick Start

Woobe Core's supported self-host topology is the root compose.yaml.

Requirements:

• Docker with Docker Compose
• Python 3 for initial environment generation

python scripts/generate_self_host_env.py
docker compose up -d --build

Then open:

Web UI:      http://localhost:8080
API:         http://localhost:8000
ChatSurface: http://localhost:8081

For public exposure, TLS, secrets, backup, restore and upgrade requirements, see docs/SELF_HOSTING.md.

Platform releases

Merging a reviewed PR into master does not publish a platform release. To release, start Actions → Release Woobe → Run workflow on master and leave version blank. The workflow calculates SemVer from commits since the last publication, synchronizes versions through a CI-validated release PR, then publishes an immutable Git tag, GitHub Release and the four GHCR packages: woobe-api, woobe-workers, woobe-frontend and woobe-embed for amd64 and arm64.

Developers do not bump manifests or create tags manually. See the release procedure for version rules, repository permissions and recovery.

Woobe CLI

Use the external Woobe CLI to manage Workspaces and Project resources, validate manifests and execute released Agents and Networks. Download the native binary for Linux, macOS or Windows from CLI releases, or run the public container package:

docker run --rm ghcr.io/a1b3rt0m3rcad0/woobe-cli:latest version

Create a Control Key under Workspace settings → CLI Keys, choose its roles and Project grants, then configure the CLI with your backend API URL. Runtime execution uses a separate Runtime Key. See the CLI guide for installation, credentials, contexts and commands.

Repository

packages/   product and distributable artifacts
tooling/    development and architecture tooling
tests/      repository and cross-system validation
scripts/    operational and CI automation
docs/       architecture, runtime and operations documentation
docker/     Docker-specific support and validation assets
deploy/     optional deployment overlays
.github/    GitHub workflows and repository automation

Product packages:

packages/
├── woobe-core/
├── woobe-api/
├── woobe-workers/
├── woobe-frontend/
├── woobe-embed/
└── woobe-ee/

woobe-core is the product Core. API and Workers may depend on Core; Core must not depend on API, Workers, Enterprise implementation or engineering tooling.

See packages/README.md, tooling/README.md, tests/README.md and docs/ARCHITECTURE.md.

Resources

• Architecture
• Self-hosting
• CLI installation and usage
• Qualified CLI deployment and recovery
• Portable Agent/Network Package import and export
• Published container packages
• Upgrading
• Runtime documentation
• Architecture Decision Records
• Security
• Contributing
• Licensing model
• Releasing

Licensing

Woobe has two explicit software boundaries: Core and Enterprise.

Core

The following packages are licensed under the Woobe Core Sustainable Use License 1.0 in LICENSE.md, except third-party components or files carrying their own license notice:

Core is source-available, self-hostable and usable in production. It may power your own commercial applications, be distributed as a component of a permitted application, and be used for genuine technical services on a customer's own deployment. The license prohibits selling the Woobe platform itself or supplying paid access to it, including a renamed fork, a hosted or managed instance, a general-purpose runtime API offering or a paid bundle. An Enterprise production authorization does not grant resale rights.

Enterprise

packages/woobe-ee/** is the Enterprise boundary, including copies, modifications and compiled forms of that material. LICENSE_EE.md permits defined non-production evaluation, development and testing. Production Use requires a valid Enterprise authorization expressly granted by Woobe in writing. Source access and installation do not grant production rights.

Independent integration code in API or other Core packages remains Core when it imports or invokes EE. Enterprise material retains its own terms; sharing a process or container does not merge the licenses.

Brand and third-party software

Woobe names, logos and distinctive brand assets are governed separately by TRADEMARKS.md. The software licenses and Enterprise production authorization grant no right to sell the platform under the Woobe brand or claim official status. Legitimate installation identification and truthful descriptive references are permitted under that policy.

Third-party software remains governed by its original licenses. See THIRD_PARTY_NOTICES.md and NOTICE.md.

LICENSING.md explains the practical boundary between using Core to power your own product and reselling the Woobe system itself.

Contributing

The integration branch is master. Feature and fix branches should start from master and target master through focused pull requests.

External contributors must accept the Woobe Contributor License Agreement. Read CONTRIBUTING.md before opening a pull request.