A community-driven registry for Claude, Cursor, Windsurf, Cline & more. Not affiliated with Anthropic.
Are you the author? Sign in to claim
Your easy to use, always-on AI workforce 👾
AI coworkers for teams with real work to do.
This repository contains the open-source Gobii Platform for self-hosting and development.
Looking for the hosted product? Start at Gobii AI coworkers.
Official Website · Docs · Discord · Gobii Cloud
Gobii is an AI coworker platform for running durable autonomous agents in production. The hosted Gobii product is available at gobii.ai; this repository contains the open-source platform for self-hosted deployments and development. Each agent can run continuously, wake from schedules and events, use real browsers, call external systems, and coordinate with other agents. Each agent can also be contacted like an AI coworker: assign it an identity, email or text it, and it keeps working 24/7.
If you are optimizing for local-first personal assistant UX on a single device, there are excellent projects for that. Gobii is optimized for a different problem: reliable, secure, always-on agent operations for teams and businesses.
Most users looking for Gobii Cloud should start at gobii.ai. Use this install path when you want to self-host or develop against the open-source Gobii Platform.
curl -fsSL https://gobii.ai/install.sh | bash
Supported installer inputs:
GOBII_INSTALL_DIR: target repo checkout directory. Defaults to ~/gobii-platform.GOBII_REF: Git ref override. Defaults to the latest tagged release.Stable installer endpoint: https://gobii.ai/install.sh
Alternatively, use the manual path:
git clone https://github.com/gobii-ai/gobii-platform.git
cd gobii-platform
docker compose up --build
For Docker-based products, the standard pattern is to validate Docker and Compose rather than install Docker for you. This installer is a thin wrapper around the existing compose.yaml bootstrap flow.
/api/v1/tasks/browser-use/ compatibility while adding platform-level runtime controls.OpenClaw is excellent software, especially for local-first personal assistant workflows and broad channel coverage. Gobii is optimized for a different target: cloud-native, secure, always-on agent operations for teams.
| Dimension | Gobii | OpenClaw |
|---|---|---|
| Primary deployment model | Cloud-native autonomous agent runtime (self-hosted or managed) | Local-first gateway and personal assistant runtime |
| Always-on behavior | Per-agent schedule + durable event queue continuity | Heartbeat and cron/wakeup session patterns |
| Webhook model | Inbound triggers plus outbound agent webhook actions in one lifecycle | Strong gateway ingress hooks and wake/agent webhook routes |
| Channel strategy | Fewer core channels with deeper lifecycle integration | Wider channel surface with intentionally thinner per-channel depth |
| Agent identity | Endpoint-addressable agent identities (email/SMS/web) | Workspace/session identity model |
| Human interaction model | Contact each agent directly through its own endpoint like an AI coworker | Primarily session/workspace-oriented assistant interactions |
| Agent coordination | Native agent-to-agent messaging | Orchestrator/subagent flows |
| Memory substrate | SQLite-native operational state | Markdown-first memory with optional vector acceleration |
| Browser runtime | Headed execution, persistent profiles, proxy-aware routing, distributed-worker friendly | Headed execution, persistent local profiles, strong local operator UX |
| Security defaults | Encrypted-at-rest secrets, proxy-governed egress, sandbox compute, Kubernetes/gVisor support | Local-first by design, sandboxing available but deployment-dependent |
| Best fit | Production team automation with governed runtime controls | Personal/local assistant workflows and channel breadth |
If your priority is secure, governed, always-on production execution in cloud or hybrid environments, Gobii is purpose-built for that.
Gobii agents are designed to behave like AI coworkers, not disposable one-off tasks. You can email or text them directly, they wake from those events, execute work, and reply with context-aware follow-through.
sequenceDiagram
participant U as You / Team
participant E as Agent Email/SMS Endpoint
participant Q as Per-Agent Event Queue
participant A as Always-On Gobii Agent
participant T as Browser/Tools/APIs
U->>E: Send message to the agent
E->>Q: Inbound event is queued
Q->>A: Wake agent with full context
A->>T: Execute tasks and gather outputs
T-->>A: Results, files, and state updates
A-->>U: Reply with outcome and next steps
A->>Q: Stay active for follow-up events
flowchart LR
A[External Triggers\nSMS · Email · Webhook · API] --> B[Per-Agent Durable Queue]
C[Schedule / Cron] --> B
B --> D[Persistent Agent Runtime]
D --> E[Tools Layer]
E --> E1[Browser Automation\nheaded + profile-aware]
E --> E2[SQLite State\nstructured memory tables]
E --> E3[Outbound Integrations\nwebhooks + HTTP]
E --> E4[Agent-to-Agent\npeer messaging]
D --> F[Comms Replies\nSMS · Email · Web]
D --> G[Files + Reports + Artifacts]
| Area | Gobii focus |
|---|---|
| Runtime model | Long-lived schedule + event lifecycle |
| Primary operator | Teams and organizations |
| Agent identity | Addressable communication endpoints |
| Orchestration | Always-on processing + native A2A |
| Browser workload shape | Production tasks with persisted state |
| Security posture | Controlled egress, encrypted secrets, sandbox compute |
Gobii agents are built to stay active over time, not just respond in isolated turns.
sequenceDiagram
participant S as Scheduler
participant Q as Agent Event Queue
participant R as Agent Runtime
participant T as Tools
participant C as Channels / Integrations
S->>Q: enqueue cron trigger
C->>Q: enqueue inbound event\n(email/sms/webhook/api)
Q->>R: process next event for agent
R->>T: execute required actions
T-->>R: outputs + state updates
R->>C: outbound reply / webhook / follow-up
R->>Q: continue or sleep
This gives you continuity for real workflows: queued work, retries, deferred actions, and predictable wake/sleep behavior.
Gobii is based on browser-use and adds production runtime behavior around it.
/api/v1/tasks/browser-use/.Gobii treats agents as operational entities, not just prompt sessions. When channels are enabled, each agent can be assigned identity endpoints and contacted directly like an AI coworker.
first.last@my.gobii.ai.flowchart LR
U[Team member] --> E[Agent email or SMS endpoint]
E --> A[Assigned always-on Gobii agent]
A <--> P[Peer Gobii agent]
A --> R[Reply back to human channel]
Gobii's architecture is built for production guardrails.
For sandbox compute design references:
The sandbox compute server now lives in this monorepo under sandbox_server/, with its own Dockerfile, tests, and image workflows.
curl --no-buffer \
-H "X-Api-Key: $GOBII_API_KEY" \
-H "Content-Type: application/json" \
-X POST http://localhost:8000/api/v1/tasks/browser-use/ \
-d '{
"prompt": "Visit https://news.ycombinator.com and return the top headline",
"wait": 60,
"output_schema": {
"type": "object",
"properties": {
"headline": {"type": "string"}
},
"required": ["headline"],
"additionalProperties": false
}
}'
| Self-host (this repo) | Gobii Cloud (managed) |
|---|---|
| MIT-licensed core on your own infrastructure | Managed Gobii deployment and operations |
| Full runtime/networking/integration control | Governed releases and managed scaling |
| Best for source-level customization | Best for faster production rollout |
Gobii keeps the default boot path simple, then lets you add worker roles as needed.
| Profile | Command | What it adds |
|---|---|---|
| Core | docker compose up --build | App server + worker + Redis + Postgres + migrations/bootstrap |
| Scheduler | docker compose --profile beat up | Celery beat + schedule sync for cron/event timing |
| Email listeners | docker compose --profile email up | IMAP idlers for inbound email automation |
| Observability | docker compose --profile obs up | Flower + OTEL collector services |
No. Gobii is based on browser-use, but adds persistent agent runtime behavior: schedule/event lifecycle, comms channels, webhooks, memory, orchestration, and operational controls.
Gobii can power individual workflows, but the architecture is tuned for team and business operations where agents stay active and integrate into production systems.
Yes. Gobii supports headed browser workflows and persistent profile handling for realistic web task execution.
Yes. With channels configured, each agent can be assigned its own endpoint identity (email and/or SMS), so your team can interact with it directly and asynchronously.
Agents can wake from schedules and external events (email/SMS/webhooks/API), process durable queued work, and continue across turns instead of resetting every interaction.
Gobii integrates encrypted-at-rest secrets, proxy-aware outbound controls, and sandbox compute support with Kubernetes/gVisor backend options for stronger isolation.
Use DEVELOPMENT.md for the complete local setup and iteration flow.
Typical loop:
# backing services
docker compose -f docker-compose.dev.yaml up
# app server
uv run uvicorn config.asgi:application --reload --host 0.0.0.0 --port 8000
# workers (macOS-safe config)
uv run celery -A config worker -l info --pool=threads --concurrency=4
An AI-powered custom node for ComfyUI designed to enhance workflow automation and provide intelligent assistance
Deterministic multi-agent pipeline for end-to-end software development, orchestrating CLI-based AI tools (e.g. Gemini, C
💻 A curated list of papers and resources for multi-modal Graphical User Interface (GUI) agents.
干净、强大、属于你的 AI Agent 平台 --AI agents, without the clutter.