github.com/contextgo/contextgo @v1.0.0

The next AI-native workbench

A product system that brings frontier models, code agents, project context, connectors, and remote collaboration into one working loop.

中文 · Downloads · Website · Discord Community

What ContextGo Is

ContextGo is not another chat shell, and it is not just a desktop textbox wrapped around model APIs.

It is an AI-native workbench built to solve a harder problem: how to keep agents useful over long-running work inside real projects, without losing control, polluting context, or breaking away from the user's actual workflow.

For end users, ContextGo is a next-generation AGI assistant that can genuinely help get work done.

For developers and teams, it is a full product system that combines project-based work, Agent harnessing, context governance, connectors, remote access, and multi-device surfaces.

In one sentence:

Code agents are not limited to code. With a stable harness, durable context, and real connectors, they can build anything.

The Problem It Solves

Frontier models are already strong, but long-duration agent work still breaks down in familiar ways:

• the model can reason, but long tasks drift without a stable control system
• project knowledge, personal preferences, success patterns, and failure patterns do not accumulate cleanly
• AI remains disconnected from software, documents, IM channels, browsers, and local files
• cross-device, cross-session, and cross-project usage is still high-friction
• ordinary users care about one thing: whether the agent can actually do useful work

ContextGo turns those problems into one coherent work system.

Core Concepts

1. Harness Agent

Harness Agent is the narrow qualifier behind the ContextGo view of agents.

The point is not to invent another model. The point is to add a constraint, disclosure, and governance layer around frontier models so long-running human-agent collaboration, or even pure agent execution, can stay ordered instead of becoming chaotic.

That layer is built around a few stable objects:

• project: work always happens inside a project directory
• AGENTS.md: the rules entry point and progressive-disclosure root
• docs/: deeper background, policy, and domain knowledge
• skills/: executable task-shaped context
• hooks, commands, and schedules: automation surfaces and shortcut actions

The model handles reasoning and tool use. The harness keeps it controllable inside real work.

2. Agent Group

A single agent can already work for a long time, but not every problem should be solved by one agent in one thread.

ContextGo's Agent Group model is intentionally simple and efficient rather than heavy orchestration:

• a planner aligns the direction
• generators keep producing
• evaluators keep judging
• multiple agents can research in parallel, cross-check, and race toward better decisions

The goal is not orchestration for its own sake. The goal is higher-quality output from multiple harnessed agents.

3. Context Engine

Context Engine is the stabilizer behind ContextGo.

It is a local-first context engine that continuously organizes, extracts, updates, and governs the high-value signals generated during agent work. It is not just a chat archive, and it is not just traditional vector-only RAG.

It is responsible for:

• extracting durable preferences, working style, success patterns, and failure patterns
• reducing entropy and cleaning polluted project context
• supporting cross-session and cross-project logical spaces through context space
• refining and compressing context while the user is away, then feeding it back into later work

4. Context Connector And IM Bot Channel

An actually useful agent does not just answer well. It connects into your working context and can publish results back into the collaboration channels you already use.

These are two separate product boundaries:

• Context Connector brings knowledge sources, documents, browser context, local files, and external product context into ContextGo
• IM Bot Channel publishes agents into message transports such as Telegram, Slack, Discord, Lark, DingTalk, and WeChat
• Feishu/Lark should be read as two boundaries: Context Connector > Feishu for context access, and IM Channels > Lark for bot publication

This lets agents consume real context and return results to existing workflows without mixing context connectors and message publication channels into one concept.

5. Host / Client

ContextGo uses a Host Runtime + Client Shell model by default:

• the Host is the real execution authority for tools, files, browsers, and long-running tasks
• the Client is the remote access and control surface, whether desktop, browser, or phone

In practice:

• desktop remains the primary execution host
• mobile is a natural remote control client
• remote access reuses the same WebUI / server runtime
• the Host can live on macOS, Windows, Linux, and eventually cloud machines

What You Can Do With It

• collaborate with agents inside a real software or knowledge project over time
• connect documents, browsers, local files, cloud services, and work channels
• keep agents researching, organizing, producing, and feeding results back
• start work on desktop and supervise or redirect it from browser or phone
• build your own assistants, skill bundles, and automation flows
• make your agents learn you over time instead of restarting from zero every session

The Product Surface

At the product layer, ContextGo turns those ideas into a usable workbench:

Workbench, connectors, built-in agents, context space, scheduling, and remote host

• built-in agents and Agent Packages
• composable skills, hooks, commands, and schedules
• project-level harness bootstrapping
• multi-device access and remote control
• publishing and interaction back into IM and operational channels
• an expanding set of local tools, browser actions, and external integrations

Agent publishing and channel feedback loop

It is designed both for developers and for users who do not care about the internals and only want an agent that can actually work.

ContextGo Product Matrix

Quick Start

As a user

1. Download the right build from Releases
2. Launch ContextGo and choose your local Host or remote access path
3. Start your agent workflow inside a project directory

As a developer

bun install
bun run start

Common development commands:

bun run webui
bun run test
bun run lint:fix
bun run format
bunx tsc --noEmit

Architecture Entry Points

If you want the current product model in more detail, start here:

• Architecture Overview
• Context Engine Event Architecture
• Space Product Model
• Mobile / Remote Access Model
• Release / Distribution Standards
• Agent Package Architecture

Open Source Status

ContextGo is advancing three things together:

• productized agents
• governed context
• connected software workflows

That makes it both a usable product and a fast-moving open-source system. Some parts are already stable, some are still evolving, but the direction is consistent:

• agents should not be limited to chat
• context should not be reduced to raw history
• software should be designed for both humans and agents

Community

• Website: https://contextgo.io
• GitHub: https://github.com/contextgo/contextgo
• Releases: https://github.com/contextgo/contextgo/releases