Your first session

Work normally. Eklavya runs alongside Claude; you do not need to invoke a command for each question.

The session timeline

One task, with learning along the way

Work produces concepts, answers schedule reviews, and memory carries context into a later session.

Open
Your settings and relevant project memories load.
Build
Claude, or background agents it starts, implements your request; the concepts used are logged.
Answer
One question connects a concept to the work on screen.
Continue
Your answer is recorded and schedules a review while work continues.
Return
A later session recalls project history and revisits due concepts.

For example, ask Claude to “Add JWT authentication to the Express API.” As it implements the change, it logs concepts tied to the actual code. With the default as-you-go cadence, that logging call can trigger a question. Later edits and shell commands provide further checkpoints, paced by a four-minute interval. Task completion can bring one more question, subject to the same pacing and session budget. It comes after Claude’s answer, and Claude then repeats a short version of the answer under “Back to your task:”.

For a change that spans several files, delegate_work (on by default) asks Claude to hand the building to a background agent. Eklavya says so next to your prompt, before the first edit, and reminds Claude once if it changes a second file itself anyway. If you started the chat in your main checkout and Claude made a worktree for the task, Claude is asked to point the agent at that worktree. A staged plan goes one stage per agent, in order, and Claude reviews, runs your checks and commits each stage before the next. If you say to work inline, Claude is asked to do so. Under the default as-you-go cadence, questions come one at a time while the agent works, and the task answer arrives last.

Answers are graded from 0 to 5. Concepts you struggle with return sooner; successful reviews are spaced further apart. A new session also shows a short banner: its first line shows the installed version and your settings, followed by progress. quiet: true hides that banner without disabling questions or memory. The banner has a time budget: the details that need a database read (recalled memory, the memory health line, your learning counts and level) are each computed in their own process, and one that is not ready within about seven seconds of the hook starting is left out, so a slow database costs a line, not the whole greeting.

Nothing is asked until the session changes a file: through Claude’s edit tools in any git repository, including a sibling worktree; through a shell command that changes a file in a git repository (one that starts with cd into it, or, in a session started outside any repository, names it by git -C or a path, or runs from inside it, for a repository inside the folder it started in); or in the git working tree it started in, where a commit counts but a git pull or branch switch alone does not. Files under artifacts/ or reports/ never count. With delegate_work on, Claude starting a building agent counts too. A session spent reading, researching or answering questions gets no questions, including one started in a folder that holds repositories but is not one. Enforced quizzing and /eklavya:quiz are not held back.

The default budget is four questions per session, even though the setting is named max_questions_per_task. Explicit practice and enforced gate retries can behave differently; see The dials and The commit gate.

Concepts the budget does not reach are dropped once the session is over; Eklavya does not keep a pile of questions you were never shown. A question you decline, do not know or get wrong is scheduled for review a day later, and the next quiz in that project asks it again after that session’s own work.

A checkpoint example

Why is httpOnly set on the refresh cookie here?

On supported Claude Code builds, the question appears in the side panel. If the panel is unavailable, Claude shows four choices in its question card. The terminal card has an Eklavya header; in Claude Desktop’s Code tab and Cowork, it begins with [Eklavya].

The terminal status bar shows the current focus, cadence and difficulty:

[EKLAVYA concept · as-you-go · easy]

The installer configures this status line when possible. If you already have a custom one, see eklavya statusline. Claude Desktop has no equivalent status bar; use the dashboard.

The quiz side panel (experimental)

The side panel is on by default. On a supported Claude Code build, a question appears beside the transcript while Claude keeps working. You can read and answer it at your own pace. If the panel is unavailable, the question uses Claude’s question card and Claude waits for your answer.

To use the question card everywhere:

eklavya config set quiz.panel false

The panel shows one question at a time under the Eklavya mark: the concept and tier, the question, four options with a line under each, and Other — explain in your own words. Each option is its own bordered block, and pressing its text or the line under it picks it. The one you pick gets bold white text, a thicker highlighted border and a filled teal background across the whole block (Other keeps the border and bold text but no fill, because you type inside it); the highlight means picked, never right. The question renders as Markdown, so code and bold show as written; the panel also marks function calls and camelCase or snake_case names as code when the question did not. The options and the lines under them are plain text, because a button cannot draw code. On the desktop app the question is set as a larger bold heading with room below it, the options are spaced well apart, a long option wraps onto more lines instead of being cut off, and an option’s note lines up under its text; a click on an option’s text or note picks it, and picking moves nothing; the terminal panel keeps its tighter layout. In any panel narrower than 60 cells the Eklavya mark sits above the concept and tier instead of beside them, so a narrow pane never squeezes that line into a few letters. In the terminal, press Ctrl+X then Tab to move the keyboard into the panel; the number beside an option selects it, and Tab and Enter press the buttons. The desktop app keeps your typing in its prompt even after you click the panel, so there the panel shows no shortcuts: click an option and the buttons. Picking an option only selects it; nothing is graded until you press Submit answer. In Other, Enter keeps the words you typed and moves the keyboard to Submit answer, so a second Enter sends them. Skip question is its own button and records a decline for that question. New to me — Teach me, a Claude-orange button on its own row under Submit answer, is for a concept that is new to you: it records “I don’t know” (grade 0, dont_know), shows the right answer under “New to you, and that’s fine. Here’s the answer.” in Eklavya teal instead of the “Needs another look” wording, and starts the explainer page in the background even when explain_on_wrong is off. The same concept comes back in a later question. The result replaces the question in the same panel and says Correct or Needs another look in words, with a line on why and, after a miss, the right option. If the answer promotes you, it also says which level you cleared on this project. Done closes the result, and so does a 15-second timer when no Next question is waiting. After a miss with explain_on_wrong on, the panel starts the explainer page in the background itself, without a prompt in your transcript. The page marks the option you picked, or lists the words you typed under Other after the options. If Claude Code refuses or fails to start that agent, the panel asks once more, then falls back to a prompt asking Claude to start it. That prompt, and the one Next question sends, show in your transcript as one short Eklavya line; Claude still reads the full instruction. Closing the panel with Esc hides the question without grading or skipping it; /eklavya-panel opens it again. /eklavya:quiz uses the same panel: for a round, Next question asks Claude for the next one of that same round, on the same topic and up to the number you asked for.

Your answer is graded the same way as in the card. A pick takes the grade the asking model wrote with that option when it wrote the question (4 for the right one, 2 for a near miss, 1 for one built on a misconception). Words you type under Other are graded by one model call from the panel, using the rubric in Grading and scheduling, and that call uses your own Claude usage. Either way the answer is recorded once, by the same code that records a card answer.

The panel is used only when all of these hold: quiz.panel is on, the Claude Code terminal CLI (tested on 2.1.292) or the Desktop Code tab (enabled, not yet verified on a real Desktop build) is the host, the panel has reported in within the last 90 seconds, and its last report did not say the host could not show it. Otherwise the question uses the card, exactly as before. In a terminal narrower than 144 columns an unrequested panel waits instead of opening: you see “A question is waiting. /eklavya-panel to open it.” and the question stays put until you open it. The hint under the pane, with Ctrl+X then Tab, the answer keys and Esc, shows only in a terminal; the Desktop tab shows no hint line. With quiz.panel off, the panel shows nothing, /eklavya-panel opens nothing, and questions use the card.

If auto mode blocks Eklavya

Claude Code’s auto mode judges each tool call before it runs, and a plugin cannot grant its own permissions. Eklavya makes ten calls without you asking, because its hooks tell Claude to or its panel makes them itself:

Tools	Why they run on their own
`log_session_concepts`, `get_session_quiz_plan`, `record_attempt`	The start-of-session note and the Stop hook have Claude log concepts, plan a question and record the answer. A denial here ends the turn with no question.
`upsert_concepts`, `get_learner_profile`	The tutor skill, which those hooks load, reads your profile first and links new concepts.
`panel_sync`, `panel_answer`, `present_question`	The panel polls and submits answers itself, and Claude hands it each question.
`memory_search`, `memory_get`	The recall notes point Claude at these to read earlier work.

A refusal reads like plugin:eklavya:eklavya - panel_sync (mcp) denied by auto mode, or names another of these tools. Auto mode can also deny a harmless call with an unrelated reason such as “Irreversible Local Destruction”, so a message that sounds wrong still means this fix. Add all ten to the permissions.allow list in your user settings, ~/.claude/settings.json, keeping the entries already there:

{
  "permissions": {
    "allow": [
      "mcp__plugin_eklavya_eklavya__panel_sync",
      "mcp__plugin_eklavya_eklavya__panel_answer",
      "mcp__plugin_eklavya_eklavya__present_question",
      "mcp__plugin_eklavya_eklavya__log_session_concepts",
      "mcp__plugin_eklavya_eklavya__get_session_quiz_plan",
      "mcp__plugin_eklavya_eklavya__record_attempt",
      "mcp__plugin_eklavya_eklavya__upsert_concepts",
      "mcp__plugin_eklavya_eklavya__get_learner_profile",
      "mcp__plugin_eklavya_eklavya__memory_search",
      "mcp__plugin_eklavya_eklavya__memory_get"
    ]
  }
}

Or paste this into Claude Code and let Claude make the change:

Eklavya's tools are being denied by auto mode. Add mcp__plugin_eklavya_eklavya__panel_sync, mcp__plugin_eklavya_eklavya__panel_answer, mcp__plugin_eklavya_eklavya__present_question, mcp__plugin_eklavya_eklavya__log_session_concepts, mcp__plugin_eklavya_eklavya__get_session_quiz_plan, mcp__plugin_eklavya_eklavya__record_attempt, mcp__plugin_eklavya_eklavya__upsert_concepts, mcp__plugin_eklavya_eklavya__get_learner_profile, mcp__plugin_eklavya_eklavya__memory_search and mcp__plugin_eklavya_eklavya__memory_get to permissions.allow in my ~/.claude/settings.json, keeping my existing entries.

The Desktop Code tab runs the same engine and reads the same ~/.claude/settings.json, so one rule is meant to cover the terminal and Desktop alike; a project’s .claude/settings.json also applies in both. A Desktop session in a different permission mode can still ask or refuse. An allow rule is checked before auto mode decides, so these ten calls run without being judged. Allow only these ten rather than the whole Eklavya server, which would also let tools such as memory_delete, memory_write and set_config run without asking.

One call stays out on purpose: when the commit gate finds questions switched off for the session, it tells Claude to run set_config to turn them back on. That tool can change any Eklavya setting, so allowing it would let Claude change settings without asking. Expect auto mode to ask there, and approve it when you do want questions back.

Eklavya’s other read tools (memory_timeline, memory_file_history, memory_status, memory_collections, code_outline and code_find_symbol) are marked read-only in the MCP protocol, which lets Claude Code run them in auto and plan mode without an entry. Unverified on a live host: if auto mode still refuses one, add it beside the ten.

A miss in the panel starts the explainer agent, and auto mode judges that too. It drops Agent allow rules, so no setting skips the check. If its classifier is briefly unavailable you may see eklavya:eklavya-explainer denied by auto mode. The panel asks once more, then hands the explainer to Claude, whose own start normally gets the page written, so there is nothing to fix.

If you do not know the answer

Choose “I don’t know” to get an explanation grounded in the work. Skipping moves on without one, and the question is not asked again in that session. Both receive grade 0, but Eklavya records the difference so it can respond appropriately. A correct multiple-choice answer receives at most grade 4; Grading and scheduling explains the scale.

Make it fit your workflow

Use The dials to change the pace, topic or difficulty. Use /eklavya:quiz for practice, /eklavya:progress for learning progress, and /eklavya:memory for project history. If expected questions never arrive, start with Troubleshooting.