Claude Code advisor vs kongming & /ak:advise: When Do You Need an AI Second Opinion? (2026)

- Command names and behavior (the advisor tool, @kongming, --advice, /ak:advise) were cross-checked against the Claude Code and AgentKit docs at the time of writing; these surfaces change fast, so verify the live docs before you depend on them.

What is advisory supervision in Claude Code?

Advisory supervision is a step where you ask for counsel at a hard decision point, separate from doing the work. Instead of letting the agent both decide and applaud its own choice, you insert a second voice to re-check the architecture, a trade-off, or a go/no-go call before moving on.

Claude Code ships one mechanism for this, and AgentKit adds two more. People tend to lump all three together, but they behave very differently. If you're not solid on what a subagent is, read the practical guide to subagents first, because most of the difference comes down to "does it have its own context or not." AgentKit's advisory concept is described in the official advisory-supervision docs.

"advisor" - three meanings people confuse

Before comparing, untangle the word "advisor," because it's used for three different things:

• advisor tool - Claude Code's built-in feature, a runtime tool-call.
• advisor (agent) - an AgentKit advisory agent, interview-oriented.
• /ak:advise - the command that runs that advisory interview.

And one line to avoid brand confusion: AgentKit here is the kit for Claude Code (agentkit.best, the ak CLI) - NOT OpenAI AgentKit (Agent Builder/ChatKit).

Claude Code's built-in advisor: handy, but shares context

Claude Code has a built-in advisor tool to escalate hard decisions (per the Claude Code advisor docs). Its mechanism is simple: the main session calls the advisor like a native capability, the runtime hands the current context to a stronger advisor model, that model returns a comment, and the main session reads it and continues.

The key point: it has no independent workspace or loop like a subagent. It's a single round of consultation inside the main session's context.

The upsides are real: it's fast, free (built into Claude Code), and it lives right in your flow, so there's no context switch. For a light decision - "is this approach OK?" - it's more than enough. The downside is exactly that shared context: because the advisor sees the whole plan you're following, it's easy for it to go along with you and hard for it to give a truly independent view. That's the gap kongming is built to close.

kongming: one-shot counsel in an isolated context

kongming is AgentKit's checkpoint advisory agent. Each call is a fresh round: it takes the task, the evidence, and a specific question, answers once, then closes. It runs autonomously on the strongest model without forcing you to switch your session's model, and most importantly - it returns counsel only, never code.

It's built for the points that need real thought: architecture, trade-offs, a hard debugging problem, a go/no-go call, or when you have several conflicting approaches. Because it runs in an isolated context, it doesn't "know in advance" which option you're leaning toward - so its opinion carries less bias.

Two ways to call kongming

There are two common ways:

• Call @kongming directly when you want to ask one question right then. This is more manual: you pick the moment and supply the context/evidence yourself.
• Use the --advice flag in workflow skills like ak:plan, ak:cook, ak:fix, ak:vibe. The workflow then sets the checkpoint itself, gathers the task/evidence/attempts/decision-point, and calls kongming for counsel.

In short: @kongming is you inviting the advisor in; --advice flips on a mode where the workflow invites the advisor at the important points. In a long multi-step task, --advice is handier because you don't have to remember to stop and ask. To place it correctly in your process, see the brainstorm → plan → cook → ship workflow.

AgentKit's advisor: asks questions first, then advises

AgentKit's advisor differs from both by being interview-driven: it doesn't answer in one shot but can ask you one question at a time to clarify the problem before advising. It fits when the requirements are still fuzzy and you need a dialogue to nail down "what am I actually building."

There are two ways to use it:

• /ak:advise: runs the interview right in the main session - lighter, no separate agent spawned.
• /ak:advise --agent: delegates to a separate advisor agent - it still asks one question at a time, but the advisory role is split off from the main workflow.

One interesting technical detail: a Claude Code subagent can't open a user prompt itself, so in --agent mode the advisor relays each question back to the orchestrating session and is re-spawned with your answer. That's how you still get an interview experience even though the advising runs in a separate agent.

Comparison: advisor vs kongming vs /ak:advise

Why add kongming + --advice if Claude Code already has an advisor?

Fair question: Claude Code already has an "advisor," so why add kongming and the --advice flag? It comes down to two things: depth and isolated context.

The built-in advisor shares context with the main session, which means it already knows which plan you're following. An advisor that knows the answer you expect tends to nod along - like asking the same developer who built it to test it. kongming runs in an isolated context, receives just the task and the question, so it pushes back from zero and carries less bias. The trade-off: it's a separate agent, so it costs more tokens and only ships with the kit.

To be fair: the built-in advisor isn't bad. For light daily sanity-checks, fast and free is plenty. The problem only shows up when a decision is big enough to need a genuinely independent view. To understand why a tool-call differs from a subagent in terms of isolation, see skills vs subagents vs hooks vs MCP.

Which one, when (quick decision)

• CC advisor - when you need a quick sanity-check that doesn't demand absolute objectivity. "Is this direction OK?" mid-code.
• kongming (or --advice) - for architecture calls, go/no-go, hard debugging, or when several approaches conflict and you want an objective opinion. Use --advice if you want the workflow to insert counsel at checkpoints for you.
• /ak:advise - when the requirements are fuzzy and you need to ask questions to lock the scope before starting.

Want the advisory agents prebuilt? (AgentKit)

kongming, advisor, and the --advice flag ship with AgentKit (the Engineer Kit, agentkit.best, ak CLI). To be straight so you weigh it correctly: Claude Code's built-in advisor is still free and fine for light work; the kit adds value in depth, isolated context, and workflow integration (inserting counsel at checkpoints). To see what's inside, read the AgentKit review or the Engineer Kit review.

Frequently asked questions (FAQ)

What is Claude Code's advisor?

It's a built-in tool-call for escalating hard decisions: the main session calls it like a native capability, the runtime passes the current context to a stronger advisor model, that model returns a comment, and the main session continues. It has no independent workspace or loop like a subagent.

How is kongming different from AgentKit's advisor?

kongming answers in one shot at a checkpoint and runs in an isolated context on the strongest model, giving counsel only - never editing code. AgentKit's advisor is interview-driven - it asks you one question at a time to clarify the problem before advising. One pushes back fast and objectively; the other holds a dialogue to clarify requirements.

How is @kongming different from the --advice flag?

Both call kongming; the difference is who presses the button. @kongming is you inviting the advisor and supplying the context. The --advice flag in ak:plan/ak:cook/ak:fix/ak:vibe turns on a mode where the workflow sets the checkpoint, gathers the evidence, and calls kongming for you.

How is /ak:advise different from /ak:advise --agent?

/ak:advise runs the interview right in the main session - light, no separate agent. /ak:advise --agent delegates to a separate advisor agent - it still asks one question at a time, but the advisory role is split off from the main workflow.

Why do you need "isolated context" counsel?

Because an advisor that already knows your plan tends to be biased toward it - like asking a developer to test their own build. An isolated context lets kongming push back from scratch with less bias, which suits important decisions that need an independent view.

Do kongming and advisor edit code?

No. Both are advisory roles - they return advice, not code changes. You remain the one who decides and executes; they just help you see more clearly before you act.

Conclusion

Pick by how hard the decision is: for light work use the built-in advisor for speed; for genuinely hard calls that need objectivity, reach for kongming or turn on --advice; and when the requirements are fuzzy, let /ak:advise ask questions to lock the scope. Place counsel correctly in the brainstorm → plan → cook → ship workflow, and if you want kongming/advisor ready to go, see the Engineer Kit review.