MateClaw

English

中文

English

中文

Appearance

v1.2.0 ​

Stable · 2026-05-05 · Previous stable: v1.1.137

Four things ​

Let me cut to it.

Not 60 new features. Not an architecture rewrite. Four things.

One — they're called "digital employees" now.Two — skills aren't an alias for tools anymore. They're the skeleton.Three — Claude Code, Codex, and other top-tier coding agents now show up as employees.Four — for the first time, you can actually see what each employee is doing.

That's it.

1. They're called digital employees now ​

We used to call them "agents."

That's a name an engineer picked.

An engineer hears "agent" and nods — "yep, agent, got it." A regular person hears it and frowns. What's an agent? Why do I care? What do I do with it?

When you hire a person, you don't tell them "you are an agent." You tell them — your name, what you do, what your task is today, who to come to when something breaks.

So this release we changed the name. Every "智能体 / agent" in the back office is now digital employee.

But this is not a vocabulary cleanup. It's a worldview change.

A digital employee has:

  • Role — "I'm the product researcher." "I'm customer support." "I'm the legal assistant." One sentence.
  • Goal — "I help you see how the market is moving." "I catch every customer question." Plain language.
  • Backstory — where they came from, why they exist, what they care about.

These aren't decoration. They get spliced directly into the system prompt and shape every answer.

We also shipped five career templates — open one, it works:

  • Product Researcher
  • Customer Support
  • Knowledge Curator
  • Data Analyst
  • Executive Assistant

Each comes with a role, goal, backstory, the right tools, a pixel-art avatar, and a color that belongs to that role.

You don't start from a blank page. You hire a coworker who already knows how to work.

2. Skills aren't an alias for tools anymore ​

The old "skill" was, honestly, "a list of tools plus a prompt."

A shortcut.

This release we rebuilt it.

A skill is now a full manifest. It has a name, a version, a feature matrix, the tools it needs, the external dependencies it requires, its prompt, its scripts, and a thing called LESSONS.md — what the skill learned during runs that it should remember next time.

Skills can grow. That's what LESSONS.md is for — the more a skill gets used, the better it knows when to step in and when to stay out. It writes a line: "last time the user didn't like that, don't do it again." It writes. It reads. It evolves.

Skills have a marketplace. Eight starter templates. Before installing, a preflight check runs automatically — which API key is missing, which CLI you need to install, which feature flag you need to enable. Told upfront. No more "install, hit error, debug yourself."

Skills have a creation wizard. Don't know how to write a SKILL.md? Open the wizard, click through a few steps, and you get a complete bundle — multi-file packaging, secret store, starter library, all in one.

Skills wire up to MCP. Tools declared on an MCP server automatically show up as virtual skill cards on the Skills page. Same-name skills get deduplicated — install a real one, it shadows the virtual one. That's the behavior you want.

Details all live in one drawer. Tools, features, memory, activity, lessons — five tabs in one place. The card got slimmer — six fields and one status pill. Clear beats comprehensive.

Skills are the difference between an AI that uses tools and one that develops a craft. Give it tools, it uses tools. Give it skills, it has playbooks. Give it skills with LESSONS, it has experience.

3. Claude Code is now one of your employees ​

This is the biggest pivot in this release.

I've said it before — Apple controls the whole widget. From silicon to software to OS to services, all us. I still believe that.

But some jobs, somebody else in the world is already doing better than us.

Claude Code is very, very good at writing code. So is Codex. In their own arena, they are the best.

So do we go fight them? Or do we hire them?

This release we picked the second one. We integrated ACP (Agent Client Protocol).

ACP is a protocol that lets external coding agents plug into MateClaw via OAuth or API key. Once installed, Claude Code becomes a skill card in MateClaw. Your digital employees call it the same way they call any built-in tool.

Concretely:

  • ACP endpoints auto-bridge — configure an endpoint, it shows up on the Skills page with a wrapper toolset
  • Visual env editor — every endpoint tells you which keys it needs, right in the UI
  • Per-session cwd — every ACP session gets its own working directory
  • Errors translated — when upstream returns "Request not allowed," the UI translates it into something you can act on: "your OAuth got hijacked by another app on your keychain"
  • claude-code-helper, codex-helper templates — install and go

The judgment underneath this is simple:

MateClaw is the personal AI your IT department can sign off on. It doesn't need to write every line of code itself. It needs to be the place where — when your developer uses Claude Code in their IDE, the company can manage it, audit it, and switch it off.

ACP is what makes that possible.

4. You can finally see what every employee is doing ​

The old MateClaw was a factory with no windows.

You threw a task in. Some time later, a result came out. What happened in between — black box. Which agent was running, which step it was on, where it got stuck, why it was slow — invisible.

That's the engineer's blind spot. Engineers don't need to see, because engineers have logs. People who actually use the product don't have logs. They only have trust.

This release we opened all the windows.

The biggest window is the Admin Runtime Console (Settings → System → Runtime).

Open it, and you see every digital employee currently working anywhere in MateClaw —

  • who's running, for whom
  • how long they've been running, what step they're on
  • what they're doing right this second — reasoning, calling a tool, waiting for approval
  • how many tokens used, how much memory
  • stuck? One-click force-recycle — no service restart needed

Before, you'd open the server logs, grep an agentId, line up timestamps. Now you open a browser tab.

The whole back office got remade too:

  • Avatar status ring — busy, idle, errored — visible on the avatar
  • Hero focus panel — open an employee, the most important info is the largest text at the top
  • Runbook status line — what it plans to do next, written there
  • Brand-tone time dial — multiple employees' activity laid out by time, the rhythm visible at a glance
  • Ticket-style ID tag — every task gets a service-desk-style ID you and the team can reference
  • Tool chip — the card shows which tools this employee uses most
  • Bento metadata tiles — important info organized as tiles, not tables, not lists

Dangerous actions go through mcConfirm. Delete, force-recycle, change permission — used to be the browser's native confirm dialog. Ugly, easy to misclick. Now it's a unified confirmation, consistent with MateClaw's visual language. You don't lose things by hitting the wrong button.

Streaming changed — you don't stare at "..." anymore ​

The typing animation is a lie. It pretends the AI is thinking. Most of the time the AI hasn't started thinking yet — the network is queued, the model is loading, the API is rate-limited. You watch the dots and assume something is happening. It isn't.

This release we made streaming an honest signal.

  • Thinking phase, tool-call phase, answer phase — shown separately. You know which step it's actually on.
  • Each SSE event has its own ID. Network drops and reconnects don't replay the same chunk — and don't lose chunks either.
  • Repetition detector got smarter. Used to miss it when an agent was stuck looping on the same markdown list with a transition paragraph in between. Catches it now.
  • Multi-agent delegation no longer fights itself. Each child agent runs in its isolated session, progress batched back to the parent stream — the main conversation doesn't stutter.
  • Zombie streams self-heal. Timed out, abandoned, child task crashed — cleaned up by the runtime.

Long-task "fake answers" got cut. The old behavior, on long tasks, was to guess an answer early so the user wouldn't wait. That's an engineer's misread of what UX means. Users would rather wait for the real one than get a fake one. Long tasks now require evidence-grounded answers.

A few more things ​

Wiki keeps moving forward:

  • Hot cache — frequently-used knowledge gets injected into the agent's system prompt at startup, no per-call query. Each KB has a "view / regenerate / reset" panel
  • Vision providers expanded — Zhipu GLM-V, Volcano Doubao, on top of the previous ones
  • Chat-LLM one-hop fallback — primary provider is wedged, switch to a healthy one — once, not infinite retry loops
  • Delete actually deletes — drop a raw material, the linked pages, vector chunks, and disk file go with it. No more orphans

Multimodal:

  • Tencent Hunyuan 3D — generates 3D models, previewed inline with <model-viewer>, Pro / Rapid routed by use case
  • Generative tools on a unified async pipeline — music, video, image, all on one SSE delivery channel

Security and enterprise:

  • Personal Access Tokens — long-lived credentials for headless scripts, CI, automation. Issuable, revocable, rotatable
  • Outbound webhook signing — HMAC-SHA-256 body signing so the receiver can verify a message came from you
  • Cron distributed lock — multi-instance deployments don't double-fire the same scheduled job

Channels:

  • Feishu image download on by default — vision agents can see images now
  • Feishu long messages chunked, not truncated — 5000-char messages go through whole
  • WeCom listener dedup — no more duplicate connections producing two replies

Fixes (you won't notice but will swear less):

  • Excessive tool calls in a single response are sliced safely, conversation doesn't crash
  • Currently selected agent's avatar in ChatConsole goes through SkillIcon — no more style mismatch
  • Each Model can override HTTP timeout — slow reasoning models stop getting killed
  • Shell tool honors your $SHELL on POSIX — no more forced sh
  • A cap on tool_calls per single LLM response — runaway agents can't burn your tokens
  • Child agents inherit parent conversation context — delegation doesn't drop knowledge

Full list: git log v1.1.137..HEAD.

What this means for you ​

If you're new —

Open the back office, pick one of the five career templates. Working coworker in under a minute.

If you're already using it —

Old "agents" become "digital employees" automatically — your config doesn't move. But you can add role / goal / backstory now — and the answers get noticeably better. Try it.

If you're a developer —

Browse the skill marketplace for ACP templates. If you already use Claude Code or Codex, plug them in — they become your team's capability, not just your own.

If you run production —

Upgrade — config is fully compatible. The new admin runtime console is at Settings → System → Runtime. Issue a PAT and use it from your CI integration.

If you gave up before because something didn't quite work —

Come back. Streaming is honest now, multi-agent doesn't fight, skills actually install and run, and you can see what every employee is doing.

One more thing. ​

Digital employees.

Not agents.

Not assistants.

Not chatbots.

Employees.

You give them names, roles, goals, backstories. You give them tools. You give them skills. You give them memory.

They work for you. You see them. You manage them. You can swap them out anytime.

That's what a personal AI operating system is supposed to feel like.