Compare the archived artifacts of two builds. Without path: artifacts only in one build, and which common ones changed (by Jenkins fingerprint, else by size, small files byte-wise). With path: a unified diff of a text artifact (secrets masked), or the sha256/size of a binary one.

What changed between a good and a bad build: result, duration, agent node, parameters, stage status/durations, commits in between (pipeline_changes = commits touching a Jenkinsfile or *.groovy), error groups that are new in the bad build, and env.log differences (if both builds archived env.log). Ideal for 'it worked yesterday', 'why is node A slower than node B' and for checking whether an error also occurs in green builds. good_on_node / bad_on_node pick builds by agent ('works on agent-01, fails on agent-03'; Pipeline jobs need up to 10 log reads); other_instance compares the same job across instances (no commit range).

What changed between two configuration versions of a job: a semantic list ('triggers: cron: H 3 * * * -> cron: H 2 * * *', parameters, SCM, script path, retention...) plus a unified diff of the XML. Secrets are masked in both. Default: the newest version against the one before it.

Write a NEW knowledge base draft (Markdown) to knowledge/drafts/ for human review. Call this at the end of a debugging session once the user confirmed the root cause. It never touches Jenkins and never overwrites a file. Drafts are not used for matching until a human reviews them and moves them into knowledge/ (then commit to Git).

Jobs whose LAST build failed (and optionally is unstable) within the last hours, across one or all instances in parallel. Good for a morning check or 'what is red right now'.

Jobs whose last build checked out a repository (app repo or Shared Library), across instances: 'job | STATUS #n | repo URL'. URL spellings are normalized (https / ssh / port / Bitbucket /scm/ / .git). ~1 request per instance. Jobs that were never built cannot be found this way.

Look up the team knowledge base. With job (+build) the build log is matched against every entry in scope (instance/job); with text, a pasted error message is matched. Returns matching entries with the first matching log line and the documented fix. get_build_summary already does this automatically - use this tool for a pasted error or before writing a new entry.

START HERE for any build question. Compact summary of one build: result, duration, trigger, parameters, agent node, commits, culprits (failed builds), downstream builds started by the build step (with their result), pending input steps (running builds), stages (with failed stage and its error), test counts, log size, known issues from the team knowledge base, likely root-cause error lines with line numbers, and the last meaningful log lines. Typical size: 1-3k tokens even for 30k+ line logs.

The env.log artifact (environment variables dumped by the pipeline) of a build, with secret-looking values masked. Optional regex pattern filters the lines (e.g. 'JAVA|MAVEN|NODE').

Job details: type, health, permalinks (last/lastFailed/lastSuccessful build numbers), recent builds, parameters it accepts, and children if it is a folder/multibranch project.

A job's (or folder's) configuration from config.xml as a compact summary: type, SCM repo/branches, Jenkinsfile path or inline script, parameters, triggers (cron, SCM polling, upstream), build retention, concurrency, label, freestyle build steps, Config File Provider files (managed_files), folder Shared Libraries and the credential IDs used (IDs only, never values). Needs Job/ExtendedRead. Jobs managed by JCasC/JobDSL: this is the live state; the source of truth is in Git.

Who changed a job's configuration and when (Job Config History plugin), newest first: 'timestamp | operation | user'. Use the timestamps with diff_job_config. Changes by SYSTEM usually come from JCasC / JobDSL seed jobs: then the source of truth is Git and UI changes get overwritten.

Full text of one knowledge base entry: scope, symptoms, root cause, fix, how it was found, red herrings. Content is written by the team (reviewed) - drafts are marked as unreviewed.

All detected error lines of a build, de-duplicated into groups (same message = one group with a count), in order of first appearance, with line number, stage, severity and a shortened stack trace. Severity 'warn' = error text inside a line logged as WARN (often retries, rarely the cause); category 'generic' = an 'Error:'/'FATAL:' line no specific rule knows (ranked after specific errors). Groups the knowledge base knows are annotated ('known issue', 'known noise', 'consequence of'). Generic Jenkins wrapper messages ('script returned exit code 1') are hidden unless include_generic.

A window of the cleaned console log with line numbers (max 400 lines per call). Use line numbers from the other tools. hide_noise drops [Pipeline]/download/progress lines.

One node in detail. Live: online/offline (reason), labels, every executor with the build running on it, Java version (if a monitor exposes it), disk/memory/clock. Configuration (config.xml): remote root, mode (any job / matching labels only), launch method (e.g. SSH host), node environment variables (secrets masked) and tool locations. Without Computer/ExtendedRead permission only the live part is shown.

What a running Pipeline build is waiting for (input steps): message, id, button, requested inputs and who may approve. Read only - approving or aborting stays a human action in the Jenkins UI.

What actually ran in a Pipeline build: where the Jenkinsfile came from, the git checkouts (repo, branch, commit), the Shared Library versions that were loaded (with a hint when a library branch does not match a VERSION parameter, e.g. rel-2.3 vs REL_VERSION=2.4), replay / restart-from-stage, and the slowest steps, and the Config File Provider files it provisioned. show_script=True adds the executed script (needs the Run/Replay permission).

Build queue: what is waiting, for how long, and why (e.g. 'Waiting for next available executor on label X'). Stuck items are flagged. Useful when builds 'hang' before starting.

Errors and the last meaningful lines of ONE pipeline stage (default: the failed stage). Much cheaper than the full log. Lines of parallel branches can interleave in the console; exact=True reads the stage step by step from wfapi instead (falls back to the console without the plugin).

Failed test cases from the JUnit test report (not the log): class, test, error message, shortened stack, and 'age' = number of consecutive builds this test has been failing.

Archived artifacts of a build (relative paths, optionally with sizes) and the download base URL. Read text artifacts with read_artifact; binaries (jar, zip, pdf, xlsx...) are never sent to the model - use the download URL.

List configured Jenkins instances (name, url, description, default, where the token comes from). check_connection=True also pings each instance and reports the Jenkins version or the error, the token's user and groups, whether it has admin rights, and quiet-down (shutdown) mode. reload_config=True re-reads config/jenkins_instances.yaml and config/.env without restarting the server. Also reports configuration problems and the state of the knowledge base.

List jobs recursively (folders and multibranch projects are expanded). folder: start below this folder, e.g. 'cd' or 'release'. Empty = whole instance. status: comma list filter on the last build: SUCCESS, FAILURE, UNSTABLE, ABORTED, NOT_BUILT, BUILDING, DISABLED. name_contains: case-insensitive substring filter on the full job name. Each row: 'full/job/name | STATUS #lastBuild | age'. Uses few API calls (no per-job requests).

List knowledge base entries: 'id | status | category | scope | title', plus how many builds each entry matched since the server started. query = case-insensitive text filter on title and content.

Files in a job's workspace (folders end with '/'), for files that were not archived (e.g. app-queue.log). Pipeline: the workspace of a node block of the build; with several blocks it lists them first. Shows the CURRENT state on the agent. Needs the Job/Workspace permission and a reachable agent.

Controller and agent status: online/offline (with reason), labels, executors, idle, free disk and temp space, free memory/swap, response time, clock drift, plus warnings. Static agents only; ephemeral Kubernetes agents appear only while they exist. Details of one node: get_node.

Propose an update of an EXISTING knowledge base entry instead of writing a duplicate: writes a NEW draft next to it in knowledge/drafts/ with the build URL added to builds, the extra regexes merged in and an 'Update proposal' section. Never touches the entry itself or Jenkins, never overwrites a file. Reports whether the entry matches the given build.

Read a text artifact (reports, logs, yaml, json...). With pattern it greps (regex, case-insensitive, 1 line context, max 50 matches); otherwise returns count lines from start (0 = tail). Secrets are masked. UTF-8, UTF-16 (with BOM) and cp1252 files are decoded; binary files are refused.

Content of a Config File Provider managed file (settings.xml, .npmrc, properties...) with secrets masked. Global files by default; pass folder= for files defined in a folder.

Read a text file from a job's workspace (e.g. a log the build did not archive). With pattern it greps (regex, case-insensitive); otherwise count lines from start (0 = tail). UTF-8, UTF-16 and cp1252 are decoded, binary files refused, secrets masked. Shows the CURRENT file on the agent.

Every build (not only the last one per job) started in the last hours, across one or all instances in parallel, newest first: 'job #n RESULT duration age | culprits | long-running note'. Counts per result. Uses ~1 request per instance (up to 10 newest builds per job are checked). Good for 'what ran/failed today', a morning check or a stand-up.

Error groups across the newest finished builds of one job (max 20): in how many failed and green builds each occurs, first/last build, and a verdict - 'new since #N' (regression) or 'also in green builds' (red_herring candidate for the knowledge base). Knowledge base notes are attached. Cost: one log per build (cached afterwards).

grep -C for a build log: matching lines with context lines around them and line numbers. Optionally restricted to one stage. Reports the total number of matches even if only max_matches are shown.