Show HN: Agent in 9 Lines Python

I asked myself: what would a minimal implementation of an agent look like?

Something that works out of the box, is a real agent with tool calling, but without 1000s of lines of code, without dozens or hundreds of npm or pypi dependencies. Something with just a few 'essential' features (not a whole kitchen sink that most agent harnesses come with nowadays).

An implementation close to pseudocode that you can look at in one page, everything there at a glance, no scrolling.

This is the agent.py I ended up with so far:

  import json,sys;from subprocess import getoutput as sh;from urllib.request import Request as R,urlopen
  url=sys.argv[1];h=[];b=dict(model="gpt-5.6",input=h,tools=[dict(type="custom",name="sh")])
  while p:=input("> "):
    h+=[dict(role="user",content=p)];H={"Content-Type":"application/json"}
    while True:
      o=(r:=json.load(urlopen(R(url,json.dumps(b).encode(),H))))["output"]
      h+=o;c=[i for i in o if i["type"]=="custom_tool_call"];z=r["usage"]["total_tokens"]/10500
      if not c:print(o[-1]["content"][0]["text"],f'\n[{z:06.3f}%]');break
      h+=[dict(type="custom_tool_call_output",call_id=i["call_id"],output=sh(i["input"])) for i in c]

It is a bit code golfed but I think it is fairly readable

- imports are all from stdlib (0 external dependencies!)

- assumes there is an inference api endpoint running somewhere

- assumes the inference api endpoint is openai-like

- model hardcoded to "gpt 5.6" (=> Sol), can easily be changed to e.g. open weight (kimi k3, glm 5.2 etc)

- api endpoint url is passed as arg to the python script

- configures only 1 custom tool: 'sh'

- 'sh' is sufficient for interacting with the environment in an open ended way

- new api output gets added to history ("h")

- if api output contains tool calls the tool calls get executed

- agent gives control back to user when the last model response is without tool calls

- agent message to user shows % of context window used

Noteworthy:

no dependencies other than python stdlib (!)

- less startup time

- less dependency churn

- less supply chain attack vector surface

- less code to verify and understand

no mcp, no plugins, no security theater

- if you want to add something specific: add it explicitly

- adapt the environment to give the agent access or restrict access to tools, resources, network etc (the env is the security boundary, not the harness)

no system prompt

- every token in context window is precious

- current strong models do fine without steering via system prompt (or are even harmed by long overly specific system prompts designed for models from months ago)

- system prompt or agents.md context can easily be added if needed (agent can also discover it or get prompted to read from environment as is)

how to run/deploy the agent

- design the environment you want to give the agent (container, docker, sandbox of your choice)

- start an inference api endpoint that is openai-like (support the request/response shape used in agent.py above)

- inference api endpoint can be as simple as a proxy to openai api that adds credentials/api key

- adapt as you want/need it, change the model, remove/alter context window behaviour, add tools, etc etc

Looking for any feedback you have to make it more clear or even simpler!