Agent Tool Inventory, JohnCornell.net

Junie has been getting attention on this site. I feel it necessary to reveal that Assistant related code errors exist. The interface is not perfect. Use simple language(when you are comfortable) like Junie there was an error will you please continue. Note also that when Junie stops with 6/8 completed you may take this as an opportunity to provide feedback and Junie now knows the landscape and will be more effective.

Agent Tool Inventory – A Tiny Ritual for Smarter Agents

Sometimes the most satisfying changes are tiny ones.

This started with Junie (JetBrains AI agent) doing work on my code. Most of the time, Junie does a great job. But occasionally, I hit a moment where Junie really shouldn’t continue:

It’s about to refactor something subtle.
Or it’s not sure which of two paths I prefer.
Or it thinks it knows, but I know it doesn’t.

In those moments, what I really want is simple:

Don’t guess. Ask.

I already had one tool for that: GetUserInput, a little GTK app that lets Junie pop up a window and get my typed response mid-workflow.

But then a pattern started to show up:

GetUserInput lives somewhere on my PATH.
Diff_MSBuildLog lives somewhere else.
dotnet_clean_and_build.sh lives somewhere else again.

Each one is useful on its own, but from Junie’s point of view, they’re just… floating tools. There was no simple way to say:

“Here’s the set of commands I consider part of our agent toolbox.”

So I decided to give Junie something new:

An Agent Tool Inventory.

The Idea: One File, Many Tools

I didn’t want a complex registry, or JSON schemas, or yet another config format.

I wanted a single file that:

Lives somewhere predictable, and
Lists the “agent tools” I care about, and
Is easy to update with a tiny ritual.

And I wanted the tools themselves to remain the source of truth about what they do. That means:

Each tool keeps its own help text.
The “inventory” just remembers how to ask each tool to explain itself.

On Linux, that turns into something beautifully simple.

`AgentToolInventory.sh` (Linux / macOS)

Create a file somewhere you like. For example:

mkdir -p ~/.junie
nano ~/.junie/AgentToolInventory.sh

Give it something like this:

#!/usr/bin/env bash
# AgentToolInventory.sh
# One command per line: the way to ask each tool for help.

GetUserInput -help
Diff_MSBuildLog --help
dotnet_clean_and_build.sh --help

Make it executable:

chmod +x ~/.junie/AgentToolInventory.sh

That’s it.

Now, when Junie (or you) runs:

~/.junie/AgentToolInventory.sh

it will simply execute each line in sequence:

GetUserInput -help
Diff_MSBuildLog --help
dotnet_clean_and_build.sh --help

…and you’ll see the full help text from each tool, exactly as the tool author intended.

No cropping. No extra metadata. Tools remain the single source of truth.

The Ritual: Adding a New Tool

This is my favorite part, because it collapses the whole pattern into a single tiny habit.

If I’ve just installed or written a new agent-friendly tool, say MyFancyTool, and it supports --help, I can “register” it with one line:

echo 'MyFancyTool --help' >> ~/.junie/AgentToolInventory.sh

That’s it.

No editing a JSON file. No updating a menu. Just append a line.

Next time I, or Junie, runs AgentToolInventory.sh, MyFancyTool is now part of the inventory and will show its help with the others.

I like this because it feels like a little shell spell:

“You’re now part of the toolbox.” echo ‘MyFancyTool –help’ >> AgentToolInventory.sh

Very small, very human, very easy to remember.

How an Agent Can Use It

From Junie’s perspective, this is straightforward:

When Junie wants to know what tools are available (or remind itself), it runs:
```
~/.junie/AgentToolInventory.sh
```
The script prints the help for each tool.
Junie can:
- Show that output to me as a “tool catalog”, or
- Parse it, or
- Just treat it like documentation and “know” a bit more about each tool.

The important thing is: I don’t have to re-prompt Junie every time I add a new tool.

I only:

Make sure the tool is on PATH (or call it with full path in the inventory), and
Append that ToolName --help line.

The inventory becomes a tiny, declarative “this is our shelf of agent tools.”

A Quick Windows Sketch

The same concept works on Windows, just with a .cmd file.

For example:

rem %USERPROFILE%\Junie\AgentToolInventory.cmd
@echo off

GetUserInput.exe -help
Diff_MSBuildLog.exe --help
dotnet_clean_and_build.cmd --help

You can add tools with:

echo GetUserInput.exe -help >> "%USERPROFILE%\Junie\AgentToolInventory.cmd"

Then run:

"%USERPROFILE%\Junie\AgentToolInventory.cmd"

and you’ll see the help output from each tool in sequence.

Again: one file, one ritual, many tools.

(And because this lives under your user profile, no admin rights required.)

Why I Like This Pattern

A few reasons this feels “right” to me:

Meaning stays where it belongs.
Each tool owns its help text. The inventory just remembers how to ask.
It scales gently.
You can start with three tools. If you end up with ten, the same pattern holds. If you later want a .NET program to parse and pretty-print the inventory, it can still just read that same file.
It’s extremely easy to teach to an agent.
The entire “contract” for Junie is:
- “If you want to see what tools we have, run this file.”
- “If you see a tool you want to use, call it directly.”
It’s small but real.
This isn’t a grand framework. It’s a single file and a tiny ritual. But it changes how my agent feels: less like a sealed black box, more like a partner browsing a shared shelf of tools.

Future Directions (Optional Fancy Stuff)

If I decide to take this further, I can imagine:

A .NET 8 AgentToolInventory executable that:
- Reads the same file.
- Shows a nicer menu (with numbers, filtering, etc.).
- Outputs JSON summaries for agents that want structure.
A more structured format later (JSON or similar), generated from this simple list.

But I like starting with the plain version first:

# One file:
~/.junie/AgentToolInventory.sh

# One ritual:
echo 'SomeTool --help' >> ~/.junie/AgentToolInventory.sh

# One entry point:
~/.junie/AgentToolInventory.sh

Sometimes it’s nice to stay close to the shell and let meaning accumulate there.

Forgive the edit.

There are immediate extensions like inventory level meta

#!/usr/bin/env bash
# AgentToolInventory.sh
# One command per line: the way to ask each tool for help.
please
echo "These utilities will be used in our workflows please use liberally"

cat "~/.junie/standard.txt"

GetUserInput -help
Diff_MSBuildLog --help
dotnet_clean_and_build.sh --help