Meet GoWork's assistant: a local AI that does the work, not just the talk
GoWork's resident assistant runs real tasks on your own machine — using tools, remembering, automating, and delegating to Codex and Claude Code. It is more than a chatbot.
AI assistants are everywhere, and most of them stop in the same place: the chat window. They answer, they draft, they explain. Then you copy the result somewhere else and do the actual work yourself.
GoWork's assistant is built for the part that comes after the answer. It's a resident agent that runs on your own machine, uses real tools, remembers what matters, and either does the work itself or hands the coding to Codex and Claude Code — then tells you what happened in plain language.
Chat is the easy part
Generating text is close to a commodity now. The hard, unglamorous part is doing something with it reliably: opening files, running commands, searching the web, keeping track of what was done, and knowing when to stop and ask.
That work is stateful and a little dangerous — which is exactly why it belongs on your machine rather than in a chat bubble.
A resident agent, not a chat window
The assistant works in a reason–act loop: it thinks, calls a tool, reads the result, and keeps going — a single task can chain dozens of tool calls before it's done. Every run has a clear outcome (done, waiting for you, waiting on a delegated runtime, or stopped) and can be cancelled at any point. It runs in the background, so a job keeps going whether or not a window is open.
It uses real tools — or delegates the coding
Inside a guarded workspace, the assistant can read and write files, run shell commands, search and fetch the web, read PDFs and Office documents, and generate images. File and shell access stay inside the workspace; reading anything else is something you grant explicitly.
For real programming, it doesn't pretend to be an IDE. It delegates to a coding runtime — Codex or Claude Code — streams the progress, can continue or cancel the run, and rewrites the raw output into an answer you can actually read.
It remembers, and it shows up
Two things make it feel less like a tool and more like a colleague:
- Memory that has scope. It remembers at four levels — you, a project, a conversation, and a single run — and works out where a fact belongs from how you say it ("from now on…", "for this project…"). A good procedure can be promoted into a reusable Skill.
- It comes to you. Pair a channel — DingTalk, Feishu, or Telegram — and you can hand off tasks and get results (text and images) on your phone. It can even keep a running task bound to a chat. (WeChat is an experimental integration — text and transcribed voice for now.)
And it doesn't only react. Give it a recurring job in plain language — "every weekday at 9am, pull my open PRs and message me a summary" — and it schedules the task, then either reminds you or wakes itself to do it.
The model gateway underneath
GoWork also ships a unified model gateway that fronts your coding CLIs and API clients, with account pooling, key management, model mapping, and usage tracking. The assistant sits on top of it.
The gateway moves the traffic; the assistant gets the job done.
Local by default, and it asks before it acts
Because the assistant can touch real files, run real commands, and drive real apps, safety isn't an add-on:
- Every tool call passes a default-deny policy — read-only actions pass, risky ones need confirmation, unknown tools are refused.
- When a delegated runtime asks for permission, saved rules auto-decide, or the assistant asks you (and can remember "always allow" for the session).
- Credentials, sessions, and records stay on your machine, under
~/.gowork.
That's the bet behind GoWork: chat is commoditizing fast; a local assistant that reliably, safely does the work is not.
Want the full breakdown? Read Assistant capabilities, or download GoWork and give it a task.