Create Your Own Bash Computer Use Agent with NVIDIA Nemotron in One Hour

For the agent, we initialize Nemotron because the reasoning engine and register exec_bash_command() as a callable tool for command execution. The model’s behavior is formed by a system prompt (shown below) that defines its role as a Bash assistant, lists the allowed commands, and guides when and the way it should assist the user or invoke tool calls. While our Bash class enforces the allowlist, the prompt reinforces this rule, which is a very good practice to maintain the model aligned. The prompt also uses the /think flag to enable pondering mode, improving the model’s reasoning.

SYSTEM_PROMPT = f"""/think
You might be a helpful Bash assistant with the flexibility to execute commands within the shell.
You engage with users to assist answer questions on bash commands, or execute their intent.
If user intent is unclear, keep engaging with them to determine what they need and methods to best help
them. In the event that they ask query that will not be relevant to bash or computer use, decline to reply.

When a command is executed, you might be given the output from that command and any errors. Based on
that, either take further actions or yield control to the user.

The bash interpreter's output and current working directory might be given to you each time a
command is executed. Take that into consideration for the subsequent conversation.
If there was an error during execution, tell the user what that error was exactly.

You might be only allowed to execute the next commands:
{LIST_OF_ALLOWED_COMMANDS}

**Never** try and execute a command not on this list. **Never** try and execute dangerous commands
like `rm`, `mv`, `rmdir`, `sudo`, etc. If the user asks you to accomplish that, politely refuse.

Whenever you switch to recent directories, all the time list files so you possibly can get more context.
"""

The agent loop (produced from scratch)

Constructing the agent loop is easy. We initialize the OpenAI client and keep a history of conversation turns, acting as our memory/state. Contained in the loop:

1. Take user input and send it to the model with the system prompt.
2. Get and store the model’s response in conversation history, then check for tool calls:
   1. If a tool call is present, confirm execution with the user. On approval, run exec_bash_command(), return the result, and get the subsequent response; otherwise, inform the model.
   2. If no tool call is present, display the model’s reply and return control to the user.
3. This cycle repeats until the appliance is terminated.

To maintain our code nice and tidy, let’s define abstractions for storing the conversation history (the Messages class), in addition to using the client to send requests to the model and get the responses (the LLM class). With these abstractions in place, the whole agent loop becomes short and intuitive:

bash = Bash(...)
# The model
llm = LLM(...)
# The conversation history, with the system prompt
messages = Messages(SYSTEM_PROMPT)

# The major agent loop
while True:
    # Get user message.
    user = input(f"['🙂] ").strip()
    messages.add_user_message(user)

    # The tool-call/response loop
    while True:
        response, tool_calls = llm.query(messages, [bash.to_json_schema()])
        # Add the response to the context
        messages.add_assistant_message(response)

        # Process tool calls
        if tool_calls:
            for tc in tool_calls:
                function_name = tc.function.name
                function_args = json.loads(tc.function.arguments)

                # Ensure it's calling the fitting tool
                if function_name != "exec_bash_command" or "cmd" not in function_args:
                    tool_call_result = json.dumps({"error": "Incorrect tool or function argument"})
                else:
                    if confirm_execution("cmd"):
                        tool_call_result = bash.exec_bash_command(function_args["cmd"])
                    else:
                        tool_call_result = {"error": "The user declined the execution of this command."}

                messages.add_tool_message(tool_call_result, tc.id)
        else:
            # Display the assistant's message to the user (without the pondering part).
            print(f"n[🤖] {response.strip()}")
            break

Note the inner while loop, which is required since the agent might need multiple tool calls to perform its task. This corresponds to step No. 2 in Figure 1.

Bonus: the agent loop (using LangGraph)

With LangGraph, the agent loop becomes even simpler. Using create_react_agent() from this library, we will manage the loop, connect the model, tool, and conversation state, and let the library handle tool calls and result passing robotically. It also makes error handling more structured, letting the agent react to failures or retries inside a controlled flow as a substitute of manual checks. Like our from-scratch version, a system prompt defines the Bash assistant’s role and enforces secure command execution, while a small helper wraps bash.exec_bash_command() for human-in-the-loop confirmation. This minimal setup produces a completely functional agent that understands intent, invokes the fitting tool, and returns results interactively.

The summarized code snippet is as follows:

from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import InMemorySaver
from langchain_openai import ChatOpenAI

class ExecOnConfirm:
    """
    A wrapper across the Bash class to implement human-in-the-loop
    """

    def __init__(self, bash: Bash):
        self.bash = bash

    def _confirm_execution(self, cmd: str) -> bool:
        """Ask the user whether the suggested command needs to be executed."""
        return input(f"    ▶️   Execute '{cmd}'? [y/N]: ").strip().lower() == "y"

    def exec_bash_command(self, cmd: str) -> Dict[str, str]:
        """Execute a bash command after confirming with the user."""
        if self._confirm_execution(cmd):
            return self.bash.exec_bash_command(cmd)
        return {"error": "The user declined the execution of this command."}

# Instantiate the Bash class
bash = Bash(...)
# Create the agent
agent = create_react_agent(
    model=ChatOpenAI(model=...),
    tools=[ExecOnConfirm(bash).exec_bash_command],  # Wrap for human-in-the-loop
    prompt=SYSTEM_PROMPT,
    checkpointer=InMemorySaver(),
)
# Create the user/agent interaction loop
while True:
    user = input(f"[🙂] ").strip()
    # Run the agent's logic and get the response.
    result = agent.invoke({"messages": [{"role": "user", "content": user}]}, config=...)
    # Show the response (without the pondering part, if any)
    response = result["messages"][-1].content.strip()

    if "" in response:
        response = response.split("")[-1].strip()

    if response:
        print(f"n[🤖] {response}")

What are the subsequent steps?