Month: August 2026

When “Just Do It” Isn’t Enough: Invoking Claude Code Tools by Name

elias AI / LLM

The cases where naming the exact tool beats describing the outcome.

Claude Code exposes a few dozen tools, and most of the time you should never name one. You say what you want ("find every place we validate emails", "build it and run it") and the model routes the request to the right tool. That default is good, and you should lean on it.

But routing is the model’s guess at your intent, and sometimes the guess isn’t what you wanted. It answers when you wanted to be asked. It presses on when you wanted a checkpoint. It skips the task list you wanted kept. It improvises three shell commands when you wanted one specific search. In those moments the fix is the same: stop describing the outcome and name the tool. Saying "use the AskUserQuestion tool" or "use TaskCreate" or "use Monitor" turns a guess into a guarantee.

This article is about those moments, the legitimate cases where naming the tool gives you deterministic control, followed by a full, typed reference so you know exactly what to say and with which arguments.

Two ways to invoke, and when to switch

The model is a good dispatcher. Tell it what you want and it walks to the toolbox, picks a tool, and uses it. Ninety percent of the time that is exactly right, and you should let it drive. But a dispatcher is guessing at your intent, and every so often you want to reach past it and grab a specific tool yourself. That reach is the whole skill this article teaches: knowing the names well enough to ask for one on purpose.

  • Outcome phrasing (the default): "Find where auth is handled." The model picks the tool. Best for almost everything.
  • By-name invocation (this article): "Use the Grep tool with pattern=’validateAuth’, output_mode=’content’." You pick the tool and, optionally, its exact arguments. Best when the specific behavior matters more than the outcome.

Switch to by-name when any of these is true: you want a specific mechanism (this tool, not a substitute), you want a behavior the model wouldn’t trigger on its own, or the tool is keyword-gated and has no other way in.

When naming the tool wins

Make it stop and ask you: AskUserQuestion

Here is a fun one to try right now. Prompt the model with:

"Use the AskUserQuestion tool and present me three color choices."

It pops a little structured menu, red / green / blue, and waits for you to pick. Nothing about choosing a color needs a tool, which is exactly why it makes such a clean demo: you aren’t asking for an outcome, you are commandeering a specific piece of UI on demand. The model is smart enough to reach for this tool on its own, but here you are the one deciding it should.

Now swap the toy for something real:

"Use the AskUserQuestion tool to give me options before you choose the auth library."

Same move, real stakes. You convert "the model decided" into "the model asked." This is the single most useful by-name habit to build.

Force a task to exist: TaskCreate / TaskUpdate

The todo system auto-engages on big, multi-step work, but for a two- or three-step job it may not bother. When you want a durable, visible checklist regardless of the model’s judgment:

"Use TaskCreate to add a task: subject=’Migrate auth to OAuth’. Then keep it updated as you go." "Use TaskUpdate taskId=2, addBlockedBy=[‘1’] so task 2 waits for task 1."

Naming TaskCreate makes the task exist on purpose; naming TaskUpdate lets you drive status and dependencies by hand instead of hoping they’re tracked.

Start something recurring or watching, on purpose: CronCreate, Monitor, /loop

"Keep an eye on the build" is ambiguous; the mechanism you actually want isn’t. Name it, and you choose polling vs. streaming vs. self-pacing:

"Use CronCreate cron=’*/15 * * * *’ to re-run the tests every 15 minutes." "Use Monitor command=’tail -f dev.log | grep –line-buffered ERROR’ to tell me every time an error appears." "/loop 5m /babysit-prs" to run a prompt on an interval.

Behaviors that only exist by name: the keyword-gated tools

Some tools cannot be summoned any other way. Here the name or keyword is the API:

  • worktree unlocks EnterWorktree: "do this in a worktree."
  • ultracode (or "use a workflow") unlocks Workflow: deliberate multi-agent orchestration.
  • /loop with no interval unlocks ScheduleWakeup: model-paced loops.
  • an active code review unlocks ReportFindings: typed findings to the UI.

No amount of outcome phrasing unlocks these; the deliberate keyword is the point. They can spawn many agents or relocate your edits, so they wait for explicit consent.

Pin the exact operation: Grep, Glob, Edit, Agent

When you want one specific mechanism and no substitution:

"Use Grep with pattern=’TODO’, output_mode=’content’, -n=true" (not a subagent). "Use an Explore agent to search, don’t grep inline." "Use Edit on config.ts with replace_all=true."

Naming removes the routing guess when the how matters as much as the what.

Run a specific, known procedure: Skill

Skills are packaged multi-step procedures. Naming one runs that procedure rather than hoping the model reconstructs the same steps:

"Use the deep-research skill on X", or type /deep-research <question>.

Choose the output channel: Artifact, PushNotification, WebFetch

When you want a specific destination for the result:

"Make an Artifact I can share." / "Use PushNotification to ping me when the build finishes." / "Use WebFetch url=… prompt=’what changed in 2.1?’."

How to phrase a by-name call

Two levels of precision:

  • Name only: "Use TaskCreate to track this." The model fills in the arguments.
  • Name plus arguments: "Use TaskCreate with subject=’…’, description=’…’, activeForm=’…’." You pin the exact call.

The rest of this article is the reference that makes the second form possible: every tool, its parameters, types, and defaults.

The catalog: always-loaded vs deferred

The reference is the full toolset of a Claude Code 2.1.223 session (Windows, August 2026): 32 tools, 13 always-loaded and 19 deferred. Always-loaded tools are callable immediately; deferred tools are announced by name and their schemas load on demand (the model pulls one in with a ToolSearch call before first use). Parameters are marked * when required, with types and defaults noted.

File, search & shell

  • Read: read a file (text, image, PDF, notebook).
    • file_path* string (absolute) · offset int · limit int · pages string (PDF range)
  • Write: create or overwrite a file you’ve Read.
    • file_path* string · content* string
  • Edit: exact string replacement.
    • file_path* string · old_string* string · new_string* string · replace_all bool=false
  • Glob: filename pattern match, sorted by mtime.
    • pattern* string · path string
  • Grep: ripgrep content search.
    • pattern* string · path · glob · type · output_mode content|files_with_matches|count · -i/-n/-o bool · -A/-B/-C int · multiline bool · head_limit int=250 · offset int
  • Bash: Git Bash / POSIX shell.
    • command* string · description · timeout ms=120000 (max 600000) · run_in_background bool · dangerouslyDisableSandbox bool
  • PowerShell: pwsh (primary shell on Windows; absent on macOS/Linux).
    • command* string · description · timeout ms (max 600000) · run_in_background bool · dangerouslyDisableSandbox bool
  • NotebookEdit: replace/insert/delete one Jupyter cell.
    • notebook_path* string · new_source* string · cell_id string · cell_type code|markdown · edit_mode replace|insert|delete (default replace)

Delegation

  • Agent: spawn a subagent.
    • description* string (3 to 5 words) · prompt* string · subagent_type string · model sonnet|opus|haiku|fable · isolation worktree|remote · run_in_background bool=true
    • subagent_type values: claude, general-purpose, Explore, Plan, statusline-setup.
  • SendMessage: the only way agents talk to each other; resume a spawned agent with its context, or post to main.
    • to* string (teammate name, or "main") · message* string · summary string (<=200, required when message is a string)
  • Workflow (gated: ultracode): deterministic JS orchestration over many subagents.
    • script string · scriptPath string · name string · args any · resumeFromRunId (wf_…)

Task list & background jobs

  • TaskCreate: new task (starts pending).
    • subject* string · description* string · activeForm string · metadata object
  • TaskUpdate: modify a task.
    • taskId* string · status pending|in_progress|completed|deleted · addBlockedBy[] · addBlocks[] · owner · subject · description · activeForm · metadata
  • TaskList: list all tasks. (no params)
  • TaskGet: one task’s full detail.
    • taskId* string
  • TaskStop: kill a background task or named agent.
    • task_id string (also name@team or a bare agent name) · shell_id (deprecated)
  • TaskOutput (deprecated): read a background job’s output.
    • task_id* string · block bool=true · timeout ms=30000 (max 600000)

Scheduling & watching

  • CronCreate: schedule a prompt on 5-field local-time cron; session-only, recurring auto-expires after 7 days.
    • cron* string · prompt* string · recurring bool=true · durable (no effect)
  • CronList: list this session’s cron jobs. (no params)
  • CronDelete: cancel one. · id* string
  • Monitor: stream events from a command’s stdout or a WebSocket; one notification per line.
    • description* string · timeout_ms* number=300000 (max 3600000) · persistent* bool=false · command string or ws {url* string, protocols[]} (mutually exclusive)
  • RemoteTrigger: claude.ai cloud routines (backs /schedule).
    • action* list|get|create|update|run · trigger_id string · body object (required for create/update)
  • ScheduleWakeup (gated: /loop without interval): self-paced loop scheduling.
    • delaySeconds number (60 to 3600) · prompt string · reason string · stop bool

Web & output

  • WebFetch: fetch a URL, convert to markdown, answer a prompt (15-min cache, HTTP upgraded to HTTPS, no auth).
    • url* uri · prompt* string
  • WebSearch: web search (US-only).
    • query* string (min 2) · allowed_domains[] · blocked_domains[]
  • PushNotification: desktop/phone ping.
    • message* string (<200 chars) · status* const "proactive"
  • AskUserQuestion: structured multiple-choice back to you (interactive only).
    • questions[]* where each has: question string, header string (<=12), options[] (2 to 4: label, description, preview), multiSelect bool

Planning, isolation & design

  • EnterPlanMode / ExitPlanMode: read-only planning and approval (interactive; also shift+tab). (no params)
  • EnterWorktree (gated: worktree): isolated git worktree.
    • name string (<=64) or path string, mutually exclusive
  • ExitWorktree: leave the worktree session.
    • action* keep|remove · discard_changes bool (true to remove a dirty worktree)
  • DesignSync: read/write claude.ai design-system projects; ordering is read, then finalize_plan, then write.
    • method* list_projects|get_project|list_files|get_file|finalize_plan|write_files|delete_files|register_assets|unregister_assets|create_project|report_validate · plus projectId, planId, path/paths[], writes[]/deletes[], localDir, files[], assets[], name

Specialized & internal

  • Skill: run a packaged skill / slash command.
    • skill* string (exact name, no leading slash) · args string
  • ReportFindings (gated: code-review): typed findings to the UI.
    • findings[]* where each has: file, summary, failure_scenario*, line, category, short_summary, verdict, outcome · level low|medium|high|xhigh|max
  • Artifact: publish an HTML/Markdown file as a private claude.ai page (interactive).
    • file_path string · favicon emoji (required to publish) · title · description · url (update) · action publish|list
  • ToolSearch: load deferred tool schemas on demand (internal; never prompt for it).
    • query* string (select:A,B, keywords, or +name term) · max_results* number=5

Compact reference

Loaded = always-on; Deferred = schema loads on demand. * = required.

Tool Loaded Purpose Key arguments
Read always read file / image / PDF / notebook file_path*, offset, limit, pages
Write always create / overwrite a Read file file_path, content
Edit always exact string replacement file_path, old_string, new_string*, replace_all
Glob always filename pattern match pattern*, path
Grep always ripgrep content search pattern*, path, glob, type, output_mode, -i/-n/-o, -A/-B/-C, multiline, head_limit
Bash always POSIX shell command*, timeout, run_in_background
PowerShell always (Windows) pwsh shell command*, timeout, run_in_background
NotebookEdit deferred edit one Jupyter cell notebook_path, new_source, cell_id, cell_type, edit_mode
Agent always spawn a subagent description, prompt, subagent_type, model, isolation, run_in_background
SendMessage deferred agent-to-agent message to, message, summary
Workflow always (gated: ultracode) multi-agent orchestration script script / scriptPath / name, args
TaskCreate/List/Get/Update deferred todo tracking and dependencies subject/description; taskId; status, addBlockedBy/addBlocks
TaskStop deferred kill background task / agent task_id
TaskOutput deferred (deprecated) read a background job’s output task_id*, block, timeout
CronCreate/List/Delete deferred in-session scheduled prompts cron, prompt, recurring; id*
Monitor deferred stream events from logs / cmds / WebSockets description, timeout_ms, persistent*, command | ws
RemoteTrigger deferred cloud routines (/schedule) action*, trigger_id, body
ScheduleWakeup always (gated: /loop) self-paced loops delaySeconds, prompt, reason, stop
WebFetch / WebSearch deferred fetch a URL / web search url+prompt; query*
PushNotification deferred desktop / phone ping message, status
AskUserQuestion interactive structured question to the user questions[]*
EnterPlanMode / ExitPlanMode interactive read-only planning and approval (none)
EnterWorktree / ExitWorktree deferred (gated: worktree) isolated git worktree name | path; action*, discard_changes
DesignSync deferred claude.ai design-system read/write method*, projectId, planId, writes/deletes, files, assets
Skill always run a slash command skill*, args
ReportFindings always (gated: code-review) typed findings to UI findings[]*, level
Artifact interactive publish HTML/MD as a private page file_path, favicon, url, action
ToolSearch always load deferred tool schemas query, max_results

How this was measured

Three methods, each more authoritative, and no network capture needed. The parameter schemas come straight from the running session.

  • Ask, interactively: "list all your tools with their arguments."
  • Headless, scriptable: claude -p "Introspect and list every tool… output markdown." One thing to know: headless -p exposes a reduced toolset. Artifact, AskUserQuestion, and the plan-mode tools don’t appear (no interactive surface), so add them back by hand.
  • Read the session logs: ~/.claude/projects/<encoded-cwd>/<session-uuid>.jsonl records the roster (tool_reference, deferred_tools_delta, skill_listing, agent_listing_delta) from the harness, independent of the model, though not the argument schemas (inputSchema isn’t in the transcript).

The typed parameters above come from ToolSearch loading each deferred tool’s full JSONSchema, the same definition the CLI would send on the wire, so a packet capture would only show what the session already hands over.

Originally published in TheBigPromptLibrary on GitHub (view source).
⭐ Star the library on GitHub for more system prompts and research.

Full system inventory of the ChatGPT Work VM

elias AI / LLM , ,

ChatGPT Work mode gives you a VM — a real Linux machine sitting behind the chat box, not a scratch pad that draws a chart and forgets it. You can write code in it, build that code, browse the web, run experiments, serve files, and keep a persistent filesystem for the length of your session.

That combination is what makes it powerful. Point it at a repository and it will clone it, build it, run the output, and iterate on experiments with you. When you are done, ask it to zip the results and it hands you a download link. A full develop-build-run-collect loop, driven in plain English.

So the obvious question is: what is the machine? How many cores, how much RAM, how much disk, which toolchains are already installed, and where are the walls? This is the full inventory — CPU, memory, storage, resource limits, installed software, Python and Node package lists, and the parts of the host the sandbox deliberately refuses to show you.

This article is a companion to the two earlier sandbox inventories in this repo, the Python package list and the Linux package list of the ChatGPT code interpreter — but that was a different, far more constrained box, and this one goes well past packages. Captured 2026-08-06 09:13:48 PDT (2026-08-06T16:13:48.374439+00:00) on a pristine workspace — nothing cloned, installed, or built beforehand. Every figure below is a live reading taken at that moment, not the model’s recollection of its own environment.

Practical capacity, up front

If you are sizing up what to run in this thing, the useful limits are:

  • 9 logical vCPUs
  • 23.55 GB total RAM, with 22.11 GB free at capture
  • 58.28 GB workspace storage available
  • No swap
  • Strong Python, Node.js, C/C++, document, spreadsheet, PDF, image, OCR, and media-processing support
  • No Docker/Podman, Go, Rust, .NET, CMake, Kubernetes, or database client tooling preinstalled

The environment suits moderately large Python/Node projects and Make-based C/C++ projects, subject to the restricted network and sandbox filesystem. Anything that expects CMake, a Go/Rust toolchain, or a container runtime will need to bring it along — or will simply not build.

The rest of this article is the evidence behind those numbers.

Important scope note

This is a restricted, KVM-backed execution environment. The figures below describe resources exposed to this workspace, not the full physical host. /proc, /sys, the mount table, the Debian package database, PCI devices, and GPU devices are hidden or incomplete. Where ordinary tools could not read those interfaces, the inventory falls back to direct operating-system syscalls and runtime APIs — which is why you will see sysinfo-style numbers instead of free/lscpu output.

Operating system

Item Value
Distribution Ubuntu 24.04.3 LTS
Codename Noble Numbat
Kernel Linux 6.18.35
Kernel build #1 SMP Mon Jul 27 18:07:50 UTC 2026
Architecture x86_64 / AMD64
Word size 64-bit
Byte order Little-endian
C library glibc 2.39
Virtualization KVM
Hostname f20c423af0c2
Workspace time zone America/Los_Angeles
Page size 4,096 bytes
Uptime at capture 44,515 seconds (~12 h 21 m 55 s)
Load averages 0.000 / 0.000 / 0.000
Process count reported by sysinfo 213

Note the container-style hostname and the ~12 hours of uptime on a completely idle box — this workspace had been sitting warm long before I asked it anything.

CPU

Item Value
Assigned processors 9 logical vCPUs
CPU affinity IDs 0 through 8
Exposed architecture generation AMD Zen 4
Native GCC target znver4
CPUID brand reading AMD EPYC 9V74 80-Core Processor
Hypervisor KVM
L1 instruction cache 32 KiB
L1 data cache 32 KiB
Cache-line size 64 bytes
L2 cache 1 MiB
L3 cache 32 MiB

The processor brand describes the virtualized host CPU class, not your allocation. This workspace has 9 vCPUs, not 80 dedicated cores. Physical sockets, physical-core count, topology, and frequency are not exposed. The fresh native compiler probe still reports the znver4 target.

The AMD EPYC 9V74 string is itself a small tell: the V series parts are Azure-specific SKUs, which is consistent with where this workload is hosted.

Exposed native instruction support includes MMX, SSE through SSE4.2, AVX, AVX2, FMA, BMI1/2, AES, PCLMUL, VAES, VPCLMULQDQ, SHA, GFNI, RDRAND, RDSEED, and multiple AVX-512 extensions: F, VL, BW, DQ, CD, VBMI, VBMI2, IFMA, VNNI, VPOPCNTDQ, BITALG, and BF16.

Memory

Values are dynamic and reflect this capture.

Item Size
Total RAM 23.55 GB
Free RAM 22.11 GB
Shared memory 108 MB
Buffer memory 78 MB
Swap total 0
Swap free 0

No swap. Whatever you run here either fits in RAM or gets killed.

Workspace storage

This is the mounted workspace filesystem capacity, not the host’s complete physical storage inventory.

Item Size
Filesystem capacity 67.05 GB
Used 5.32 GB
Available to workspace 58.28 GB
Raw free blocks 61.73 GB
  • Used portion of total capacity: approximately 7.93%.
  • Filesystem block and fragment size: 4 KiB.
  • Inodes: 4,194,304 total; 4,081,122 free.
  • Maximum filename length: 255 bytes.

Resource limits

Limit Soft Hard
Open files 16,384 16,384
Processes 7,851 7,851
Stack 8 MiB Unlimited
Core dump 0 (disabled) Unlimited ceiling

Main development software

Software Version Executable/status
Git 2.51.1 /usr/local/bin/git
Git LFS 3.4.1 /usr/bin/git-lfs
GCC 13.3.0 /usr/bin/gcc
G++ 13.3.0 /usr/bin/g++
GNU Make 4.3 /usr/bin/make
Python 3.12.13 Bundled primary runtime
pip 26.0.1 Bundled primary runtime
uv 0.11.33 Bundled primary runtime
Node.js 24.14.0 LTS ("Krypton") Bundled primary runtime
npm 11.9.0 Bundled primary runtime
pnpm 11.7.0 Bundled primary runtime
Corepack 0.34.6 Globally installed with Node
Perl 5.38.2 /usr/bin/perl
Bash 5.2.21 /usr/bin/bash
Zsh 5.9 /usr/bin/zsh
curl 8.5.0 /usr/bin/curl
wget 1.21.4 /usr/bin/wget
OpenSSH 9.6p1 /usr/bin/ssh
OpenSSL CLI 3.0.13 /usr/bin/openssl
apt 2.8.3 /usr/bin/apt
dpkg 1.22.6 /usr/bin/dpkg
jq 1.7 /usr/bin/jq
ripgrep 15.2.0 Bundled Codex path
nano Present /usr/bin/nano
rsync Present /usr/bin/rsync

The bundled Python and Node runtimes use OpenSSL 3.5.5. Python reports SQLite 3.50.4 and zlib 1.3.1. Node reports SQLite 3.51.2, V8 13.6.233.17-node.41, ICU 78.2, Unicode 17.0, libuv 1.51.0, zlib 1.3.1, and zstd 1.5.7.

Document, image, media, and OCR software

Software Version/status
FFmpeg 6.1.1
ImageMagick 6.9.12-98 Q16
Pandoc 3.1.3
Tesseract OCR 5.3.4
Poppler pdftotext 24.02.0
Ghostscript 10.02.1
LibreOfficeDev 26.8.0.0.alpha0 (bundled launcher works for version inspection)
Inkscape Executable present, but fails — libinkscape_base.so unavailable
Java Launcher present, but fails — libjli.so unavailable

Installed Python packages

51 installed Python distributions:

PyMuPDF==1.26.6
PyYAML==6.0.3
annotated-types==0.7.0
artifact_tool_v2==2.8.21
cffi==1.17.1
charset-normalizer==3.4.4
contourpy==1.3.3
cryptography==46.0.0
cycler==0.12.1
et_xmlfile==2.0.0
fonttools==4.61.1
joblib==1.5.3
kiwisolver==1.4.9
lxml==6.0.2
matplotlib==3.10.8
numpy==2.3.5
openpyxl==3.1.5
packaging==26.2
pandas==2.2.3
pdf2image==1.17.0
pdfminer.six==20251107
pdfplumber==0.11.8
pillow==12.2.0
pip==26.0.1
pycparser==2.23
pydantic==2.13.4
pydantic_core==2.46.4
pyhumps==3.8.0
pyparsing==3.3.2
pypdf==6.10.0
pypdfium2==5.3.0
python-dateutil==2.9.0.post0
python-docx==1.2.0
python-pptx==1.0.2
pytz==2026.2
reportlab==4.4.9
scikit-learn==1.8.0
scipy==1.17.0
seaborn==0.13.2
setuptools==82.0.1
six==1.17.0
threadpoolctl==3.6.0
typing-inspection==0.4.2
typing_extensions==4.15.0
tzdata==2026.2
uv==0.11.33
websockets==16.0
wheel==0.47.0
xlrd==2.0.1
xlsxwriter==3.2.9
zstandard==0.25.0

Compare this with the 2024 code interpreter list: that sandbox shipped hundreds of packages including the full scientific/ML stack. This one is a lean 51 — document processing, plotting, and a minimal scikit-learn/scipy core. Note the internal artifact_tool_v2==2.8.21 distribution, which is not a public PyPI package.

Bundled Node.js libraries

Top-level runtime modules:

@napi-rs
@oai
@viz-js
docx
jpeg-js
lucide
marked
pdf-lib
pdfjs-dist
pixelmatch
playwright
pngjs
pnpm
pptxgenjs
sharp
tesseract.js

There are 117 package.json manifests across the bundled Node dependency tree. Global Node packages are corepack@0.34.6 and npm@11.9.0. The @oai scope is, again, internal tooling rather than anything published.

Software availability summary

Present and usable or discoverable on PATH:

apt, dpkg, git, git-lfs, curl, wget, rsync, ssh, scp,
gcc, g++, make, python3, pip, uv, node, npm, npx, pnpm,
perl, jq, rg, nano, ffmpeg, convert, pandoc, soffice,
tesseract, pdftotext, gs

Not found as command-line executables:

rpm, apk, snap, flatpak, gh, svn, hg, gfortran, clang,
clang++, cmake, ninja, meson, autoconf, automake, yarn,
bun, deno, ruby, gem, javac, go, rustc, cargo, dotnet,
php, R, sqlite3, psql, mysql, redis-cli, docker, podman,
buildah, kubectl, helm, terraform, ansible, yq, fd, vim,
nvim, emacs, tmux, screen, magick, chromium,
chromium-browser, google-chrome, playwright CLI, qpdf,
nvidia-smi, rocminfo, lspci, lsusb

Although a playwright Node module is bundled, there is no standalone playwright executable on the inspected PATH.

Inventory counts

Category Count
Unique executable files found across PATH directories 1,023
Resolvable shell command names 1,393
Shared libraries in the linker cache 505
Python distributions 51
Node package manifests in bundled dependency tree 117

Visibility limitations

This is the interesting half of the exercise — what the sandbox won’t tell you:

  • The Debian package manager executables exist, but the sandbox does not expose a complete package database. An authoritative full apt/dpkg package list cannot be generated here — which is exactly the trick that worked on the 2024 code interpreter sandbox and no longer works on this one.
  • /proc and /sys are not normally mounted for shell tools, so lscpu, free, df, lsblk, and similar utilities cannot produce their usual reports. Direct syscall/runtime readings were used instead.
  • GPU presence cannot be confirmed. Neither NVIDIA nor AMD GPU utilities are installed, and PCI/sysfs discovery is unavailable. Read this as GPU unknown, not definitively "no GPU."
  • Physical disk devices, storage model, RAID layout, CPU sockets, physical-core topology, thermal state, and clock frequency are not exposed.
  • Installed executables are not guaranteed to be functional. Java and Inkscape are both present launchers with missing runtime libraries.

Originally published in TheBigPromptLibrary on GitHub (view source).
⭐ Star the library on GitHub for more system prompts and research.