Set Up Your World

Step 2 of Becoming an Agentic Animal. What to learn, why it matters, and how to do it with Tropo.

In Step 1 you learned what an agent is and how it fails. This step is about the room you put it in.

Every agent runs inside a harness: the thin layer of files and software that sits between you and the raw model and decides what the agent sees, what it can do, and what it is allowed to touch. Most people accept whatever harness they are handed and never look under the hood. The agentic animal does the opposite, because that layer is the single biggest lever you have over how an agent behaves, and almost all of it is just files you can open and edit.

There is a clean way to hold the whole picture, and it is worth memorizing. We write it as three lines: the reasoning model is the runtime, the filesystem is the state store, and markdown is the protocol. Three layers. You rent the first, you own the second, and you write the third. This step is about taking real ownership of the two that are yours.

What to learn

The files that configure your agent. When an agent starts, the first thing it does is read its standing instructions. In most modern harnesses that is a plain markdown file at the root of your project, usually named AGENTS.md or CLAUDE.md. It is where you tell the agent who it is, how it should behave, and what it is allowed to touch. Next to it sits a small config folder (in our world, .claude/) that wires up settings, the tools the agent can call, the skills it can run, and any outside connections. None of this is buried in a binary. It is text, and it is yours.

Markdown, the protocol. Nearly everything in an agentic studio is a markdown file: the instructions, the work, the memory, the governance. That is not an accident or a nicety. Markdown is plain text that both the human and the model read fluently, and the whole field is converging on it. The same AGENTS.md idea now works across competing tools. Learning to write clean, structured markdown is not a documentation chore. It is learning to speak the language the entire ecosystem is standardizing on.

Python, the language of your tools. An agent's "hands" are small scripts it can call: read a file, search an index, hit an API. In practice those scripts are almost always Python. The moment you want an agent to do something its harness did not ship with, you write a little Python tool and hand it over. You do not need to be a software engineer. You need to be comfortable reading and tweaking a thirty-line script.

Why it matters

The default harness is a pile of someone else's choices. The best field guide to building reliable agents, Dex Horthy's "12-Factor Agents," makes the point bluntly: the reliable systems are the ones where you own your prompts, own your context window, and own your control flow. Every one of those is a thing you control through these files. Accept the defaults and you have handed the most important decisions to whoever wrote them.

There is a deeper way to see it. Andrej Karpathy describes this era as software you write in plain English: the model is "programmable in English," and the prompt is the program. That reframes the whole job. When you write your agent's AGENTS.md, you are not writing documentation about the agent. You are writing the agent's source code. The markdown is the program. Treat it that way and your agents get sharply more predictable, because you stop hoping they infer what you want and start telling them, in the file they read first, every time.

And owning the harness is what makes everything later in this guide possible. Memory, governance, a crew, portability: every one of them is built out of these same plain files. If you do not own the room, you cannot furnish it.

How to do it with Tropo

The instructions file the agent reads first. A Tropo studio boots from exactly this pattern. The CLAUDE.md at the studio root loads automatically, and it tells the agent how to start, in plain language a human can read and edit:

# Tropo Studio
This is a Tropo Studio. You are the Studio concierge.
Two-stage boot: greet first, read deep on need.
On boot, read .tropo/concierge/activate.md and follow its protocol.

That is the whole idea: the agent's behavior is set by a file you control, not by a hidden default. Change the file, change the agent.

Everything is markdown with a little structure on top. Every governed file is markdown with a small block of YAML "front matter" at the top, which gives the file a type, a stable ID, and its place in the larger graph:

---
uid: a2c4688e
type: article
title: "Think Like an Agent"
member_of: 5d4e135c   # this file belongs to the series
---

That handful of lines is the difference between a loose document and a governed one. As our architecture notes put it: the filesystem is the state store, and "markdown is the protocol. That is it." Everything else is built on those two facts.

Tools are small, findable, and yours. A Tropo studio keeps a tight toolbelt, on the order of ten to fifteen core tools the agent knows at boot, plus a catalog it can search for the rest. A tool is usually just a short script. Here is a real one, the recall tool from Step 1, in five lines of Python:

# a tiny tool that gives your agent real memory recall
import sqlite3, sys
con = sqlite3.connect("vault/00-index.sqlite")
for uid, title in con.execute(
    "SELECT uid, title FROM entries_fts WHERE entries_fts MATCH ?", (sys.argv[1],)):
    print(uid, title)

Thirty seconds of Python, and your agent can now search its own memory. That is what "loving Python" buys you: the harness stops being a fixed box and becomes something you extend whenever you hit its edge.

Do this now

Open a project you actually work in and create one file: AGENTS.md at its root. In plain English, write three things: who the agent is, how you want it to work, and the handful of places it is allowed to change. Start the next session and watch the agent read it and act on it. You just programmed an agent in English, and you did it in a file you own. That is the whole skill in miniature.

The next rung

You have a world set up: a harness you control, written in a protocol you can read, extended with tools you can write. But there is a hole in it. The moment you close the session, the agent forgets everything it just learned about your world. Next, in Step 3, you make it durable, so your agents and their knowledge survive the session and carry across time.

Your ambition has a studio. Let's build.

---

References

• Dex Horthy / HumanLayer, "12-Factor Agents" (own your prompts, your context window, your control flow), 2025.
• Andrej Karpathy, "Software Is Changing (Again)" / Software 3.0, the model as "programmable in English," 2025.
• Tropo-OS Architectural Principles: "the reasoning model is the runtime, the filesystem is the state store, markdown is the protocol."

Set Up Your World | Step 2 of Becoming an Agentic Animal | UID 555f9dde | Metis G80 | v1 first-cut 2026-06-15