Agent Harnesses with Claude — Intuitively and Exhaustively Explained
Towards faster, less expensive, more maintainable, and more consistent agents
A few weeks ago I released a piece called “Agent Harnesses”. The objective of that piece was to soft release and understand other people’s perspectives on a fledgling project I’ve been working on; a new standard for agentic design called “Agent Harnesses”.
In my career thus far, I’ve experienced the following truths:
No great things are made in a vacuum
Negative feedback is often the most productive feedback
My goal in creating agent harnesses is to design a standard that democratizes the creation of sophisticated and robust agentic systems. To do that effectively, I knew I needed to expose my ideas, fledgling as they were, to an environment of criticism. I had a wider vision of “Agent Harnesses” than what was outlined in my previous article, but I needed feedback to give that vision a form so I could be confident moving forward.
Since writing that piece, I’ve been working hard to flesh out my understanding, have been exploring other peoples approaches to developing modern agentic systems, and have spent much time reflecting on other people’s perspectives. I now feel comfortable peeling another layer off of agent harnesses, exposing it at a greater depth, and sharing how it can be used to practically build robust and efficient agentic systems with Claude.
Before I get into the meat of it, though, I want to take a moment to address a fundamental question.
What is a Harness?
The term “harness” is being passed around by different cutting edge AI organizations, kind of like how hip cool kids talk about a hangout spot you’ve never been invited to. You’re not sure what they’re talking about, or if they’re even talking about the same thing, but you’re sure there’s something going on.
If you ask Google what a harness is, you’ll get this answer:
In AI, an agent harness is the supporting software infrastructure that wraps around an AI model (like an LLM), giving it the tools, memory, and environment to take real-world actions
So, from Google’s perspective, a harness is the supporting software that allows LLMs to do agentic things, though exactly how the code wraps around the model is somewhat vague.
This post by Anthropic discusses a “harness for long-running agents”.
We developed a two-fold solution to enable the Claude Agent SDK to work effectively across many context windows: an initializer agent that sets up the environment on the first run, and a coding agent that is tasked with making incremental progress in every session, while leaving clear artifacts for the next session.
In that article, Anthropic links to this github repo. It uses two “agents”, an initializer and a coding agent, to solve problems. These “agents” both use the same python script, but employ different starting prompts; one for coding and one for initialization. So, in this post, a harness contains agents, and coordinates them to solve problems.
This article by LangChain thinks of a harness differently.
Building useful agents is largely about customization: connecting your agent to the right context, data, and environment(s) for the task at hand…. The job of a harness is to get the model the right context at the right time for the given task.
They define a harness as being the code that turns an AI model into an agent
agent = model + harness
which is a bit confusing because the anthropic example uses two agents to build a harness. Are harnesses used to build agents, or are agents used to build harnesses?
If you look through the various mentions of harnesses online, the high level idea of a harness will be largely equivalent, but if you ask probing questions you’ll find that two people using the term “harness” might actually be discussing two totally different things.
The most common sentiment I’ve found is that a harness is a set of rigid programs that enable an LLM to do things other than respond to text, like understand state, execute tools, and operate in complex environments
An actual harness is the infrastructure around the LLM. These are things like memory, state, persistence, guardrails, sanboxing. This is deterministic software that quite literally harnesses the probabalistic language model. It’s not some markdown files, it’s big infrastructure.
— A response I got on my previous article which, by the way, I was very happy to receive. I quote this with great appreciation to the comment and commenter. If you would like to be mentioned by name, I would be more than happy to edit this quote.
A true harness lives outside the context window: It is the heavy, deterministic infrastructure wrapping the LLM and includes things like isolated sandboxes, state persistence engines, memory routers, and hard guardrails.
— Another response I received with gratitude, same offer applies as the previous.
A harness provides an agentic looping environment for use cases where the AI is supposed to loop until it solves the given task (like coding). — Source
The issue I have with this definition is that it bears a significant overlap with the definition of an agent. An “agent,” by definition, is a set of rigid programmatic tools that connect an LLM with state and abilities so that it can execute tasks in complex environments.
If “it’s code that lets LLM do things” were to become the working definition of a harness, I don’t feel it would benefit the community, but instead lead to confusion by rebranding an already established idea. That’s what an agent is.
Thankfully, there is another popular definition of a harness.
most “harnesses” are still thin wrappers around prompts, tools, and state, and the hard part is not structure, it’s evals, failure handling, and keeping behavior stable after one small model change. that part is where most agent stacks die
— Another quote I received, with tremendous gratitude, from a fellow writer on Medium.
Along with chats like this, and this, there’s an implication that a harness isn’t so much programmatic agentic code, but rather something that is applied to an agent to get it to do something specific.
This definition, that a harness is something that agents connect to that applies them to specific problems, is something that I resonate with. I’m personally of the opinion that, if there is a functional definition of a harness, it is that.
A harness is information and tools that allow a general purpose agentic system to do specific, complex tasks in a repeatable and maintainable manner.
I like this definition, partly because it doesn’t step on the toes of the definition of an agent, but also because I think it’s a practically vital concept on the cutting edge of AI application development.
The Context in Which Harnesses are Being Defined
I think there are two fundamental ideas that are critical in understanding why harnesses matter, and that is “agentic constraint” and the “agent skills standard”.
Context: Agentic Constraint
“Agentic constraint” is a phrase I made up, but it’s been bouncing around conceptually for years now. It can be boiled down into a simple question: how granularly do you constrain your agent?
Do you let it do whatever it wants by thinking through problems, like a ReAct style agent?
Or do you lock it down, and define a rigid structure that an agent has to navigate within?
Generally, when thinking about agents over the last few years, I’ve put them into two buckets: “constrained agents”, which follow a human interpretable and editable logical path, and “unconstrained agents”, which are allowed to think through problems on their own. There are costs and benefits to both approaches; constrained agents are more deterministic and understandable and are therefore easier to maintain. Unconstrained agents are flexible, which can allow them to do arbitrary tasks and also to fail in arbitrary ways.
Context: Agent Skills
Agent Skills are a big deal. It’s a standard that’s changed the way agentic systems work on a fundamental level. I cover it in this article
and the spec can be found here
A skill is, in its essence, a folder with a markdown file. That’s it.
Literally, that’s it.
It’s so simple that it can feel laughable to call it a standard, a stance I took when covering it initially
Brief aside, I haven’t been impressed with how “vibey” specifications around AI, LLMs, and Agents often are. If we don’t know where files are, or have a rigid specification around them, how can we enforce progressive exposure (which is one of the major objectives of the agent skills specification)? Also, should all of the output specifications be in
FORMS.md? Should some of it be inREFERENCE.md, or other more specific references within thereferencesdirectory? How can we enforce output formats if we don’t even know where the output formats are supposed to be? — from my article on skills
Frankly, I was wrong. That’s been happening more as I’ve been covering the bleeding edge, I suppose it’s something I’ll just have to get used to.
I stand by the opinion (at least for now) that there are attributes like FORMS.md that are vaguely defined and hardly adopted, but the core of the skills specification is inspired. It’s inspired because of one simple thing:
It allows the people writing skills, and the agents using skills, to leverage a shared agreement on structure.
This is fundamental and absolutely critical. Simple things, like the markdown file that defines a skill having a name and a description, allows agentic systems to index, scan through, make decisions on, and leverage resources within multiple skills efficiently and (somewhat) predictably. Skills make functionality in agents portable, maintainable, and efficient, and are thus gaining adoption pretty much anywhere agents run in the real world.
Just the other day, my partner asked Alexa if it could play rainforest noises, and alexa said it “encountered an error when running the rainforest noises skill”. The biggest productionalized AI systems are using skills under the hood.
In a nutshell, constraints are a fundamentally important tool in designing AI systems, and skills are a monumental leap forward in making agents practically useful through standardization. I don’t think it’s enough, though, which is why I’m working on the agent harnesses standard. Before I explain the standard I’m working on, I want to take a moment to explain limitations around the current status quoe of agentic design.
Limits of Constraints and Skills
The only time I’ve talked publicly about agent constraints is in a reddit post where I break down my approach to making AI systems improvable. The essential idea is that graph-based agents are easier to make robust when working on complex tasks, whereas unconstrained “ReAct-esque” agents can be finicky to improve reliably.
This unconstrained approach isn’t so great, I’ve found, when you build an AI agent to do something specific and complicated. If you have some logical process that requires a list of steps and the agent messes up on step 7, it’s hard to change the agent so it will be right on step 7, without messing up its performance on steps 1–6. It’s hard because, the way you define these agents, you tell it how to behave, then it’s up to the agent to progress through the steps on its own. Any time you modify the logic, you modify all steps, not just the one you want to improve. I’ve heard people use “whack-a-mole” when referring to the process of improving agents. This is a big reason why.
I call graph based agents “constrained agents”, in contrast to the “unconstrained agents” we discussed previously. Constrained agents allow you to control the logical flow of the agent and its decision making process. You control each step and each decision independently, meaning you can add steps to the process as necessary. — From my Reddit post on improvable AI
This is great; if you want to make a super reliable agent just use a graph. The issue is that, for even the most simple of tasks, a decent graph can be incredibly difficult to build. Later we’ll be discussing a harness that can be loaded by the Claude CLI to help someone apply to jobs. In theory this is a simple job that could be defined as a graph:
look for job opportunities
write a resume
help the user answer questions and help with application
Great… accept what about the user wanting to review resumes? What about the user having specific requests for specific resumes for specific job opportunities? What about if the job listing requires JS rendering to be viewed properly? What about if some job listings have an option for a cover letter, and some don’t? What if the user has specific rules they want the agent to follow when crafting a resume? What if the user wants to skip all this stuff and just use the agent to help them answer questions for a form in a job posting?
As humans we experience this all the time. Chefs, drivers, artists, writers, project managers, software developers. We all have a little graph of what our job is in general: you do this, then this, then this, then that. Except when you have to do this. Also sometimes that happens. The graph of procedures we use to govern our lives exists, but it’s fuzzy. We have a structure to help us, but that structure must be supplemented with contextual decision-making that exists outside of any structure. So, building super rigidly constrained agents isn’t enough.
The skills standard also isn’t enough. let me be clear, I think skills are vital and fundamental, but we need something else on top of them.
Right now, modern agentic systems typically look something like this:
A
.claudedirectoryA bunch of skills in the
.claudedirectoryA
README.md, and some other markdowns, that describe how the agent ought to behave.
I didn’t know this until recently, but this approach was proposed and coined by Karpathy in the form of an “LLM Wiki”:
The idea here is different. Instead of just retrieving from raw documents at query time, the LLM incrementally builds and maintains a persistent wiki — a structured, interlinked collection of markdown files that sits between you and the raw sources. When you add a new source, the LLM doesn’t just index it for later retrieval. It reads it, extracts the key information, and integrates it into the existing wiki — updating entity pages, revising topic summaries, noting where new data contradicts old claims, strengthening or challenging the evolving synthesis. The knowledge is compiled once and then kept current, not re-derived on every query. — source
This is great, and actually works remarkably well; people are using a bunch of skills and a bunch of markdown files to automate all sorts of stuff right now.
Agree. We are using a version of Karparthy’s LLM Wiki as a harness and it works perfectly at the scale we need. It builds the graph by itself as needed and also restructures it by itself while it grows. — Another response I gratefully received on my agent harnesses article.
However, if you use this approach for long enough on sufficiently complex tasks, you start to identify a few problems:
Every time you start a new session with an agent, it completely forgets your entire wiki. You might have things written down, but if an agent doesn’t find and load that into context, it will ignore what’s written.
For big tasks you need a lot of skills, reference files, assets, MCP servers, and other stuff. A flat folder structure containing an exhaustive list of skills and MCPs becomes difficult to maintain, just like having all of your files on your desktop rather than organized by folders would become difficult to maintain. In complex systems, you need to organize tools and information in complex hierarchical ways.
By employing skills and an LLM Wiki alone, the following issues have a tendency to occur:
It can take forever for an agent to understand the environment it’s working in on initialization
Or, the agent doesn’t take the time to understand its environment, and completely ignores documentation
If you use an LLM to maintain a Wiki, it forgets where it wrote things and creates disorganized, duplicate, and contradictory information
It’s difficult to configure an LLM Wiki, as the agent has a tendency to put whatever, wherever. On large LLM Wiki’s, making minor adjustments in an agent’s decision-making can be challenging
When working in claude, you’ll find further issues
Skills must obey a flat structure within
.claude, and can’t be organizedThus, skills can’t be packaged within a greater context. If you have high level prompts that describe a role in a directory structure, you have to pair that with a
.claudedirectory with the correct corresponding skills
The goal of the “Agent Harnesses” spec is to alleviate these issues by:
Making the degree of constraint the harness proposes on the agent easily configurable by a maintainer.
Creating a defined routing system within a directory structure that both humans and agents can understand to make decisions and maintain information.
Allowing all types of context and tools to be bundled arbitrarily within that directory structure.
Expose all of this information in an efficient and predictable manner, allowing agents to perform a task consistently and efficiently.
As I said before, the Agent Harnesses spec is currently in active development. It’s still in soft-release territory. That said, I want to briefly share some of the new constructs within it, and an example of an efficient harness allowing for complex yet maintainable functionality using claude CLI.
Concepts in Agent Harnesses
Agent Harnesses is heavily inspired by both MCP and Agent Skills, but it’s particularly inspired by agent skills. The structure of the project is virtually a copy of Agent Skills, down to the service running the website.
The most fundamental inspiration Agent Harnesses takes from Agent Skills is that of “progressive disclosure”. Progressive disclosure is the idea of allowing an agent to peek at a summary of information before considering a large amount of information. When you make a skill, you define a high level description. When the agent is looking for a skill to solve a problem, it can use these descriptions to peek at many skills efficiently, then choose which ones are worth looking into more.
skill: send_email
desc: Send emails via SMTP or Gmail API. Handles attachments,
HTML formatting, and bulk sending.
skill: query_database
desc: Run SQL queries against PostgreSQL or MySQL. Returns
structured results and handles connection pooling.
skill: resize_image
desc: Resize, crop, or convert images between formats (PNG,
JPEG, WebP). Supports batch processing.
skill: parse_pdf
desc: Extract text, tables, and metadata from PDF files.
Handles scanned docs via OCR.
skill: call_rest_api
desc: Make authenticated HTTP requests to external APIs.
Supports OAuth, API keys, and retries.The Agent Harnesses standard uses key files to achieve a similar effect, but across an entire directory. Just like Agent Skills, this simplicity is what makes Agent Harnesses powerful.
All of the files defined in the Agent Harnesses standard are designed to do two things:
Provide information as it’s needed to the agent
Provide references to where further information can be found
The core of a harness is a HARNESS.md file, which is at the root of the harness directory. It’s essentially a README.md file designed for agents, providing high-level information so the agent can understand the fundamentals of the harness at a glance.
Within the root of a harness there will likely be various sub-directories. These “top-level subdirectories” are important to the agent harnesses specification as they define the macroscopic buckets used to organize the agent. These top-level subdirectories can be arbitrarily defined, but should be considered based on the application your working on. You might have a harness that looks like this
marketing-assistant-harness/
├── HARNESS.md
├── capabilities/
├── brand/
└── campaigns/or this
data-analyst-harness/
├── HARNESS.md
├── tools/
├── data/
└── outputs/or this
tech-support-harness/
├── HARNESS.md
├── playbooks/
├── integrations/
└── environment/whatever works for the project you’re working on.
Agent harnesses uses these top-level subdirectories as keywords used to define markdown files that route within them. If you have a tools/ top-level subdirectory, the agent harnesses spec expects markdown files called TOOLS.md to be used to provide routing information throughout the subdirectories within tools/.
Here’s an example of a harness structure. Notice how TOOLS.md exists in tools/, tools/database/, tools/files/ , tools/compute/ , and tools/external/. because tools/ is a top-level subdirectory within the harness, it looks to TOOLS.md to provide routing information within. Also, notice how data/ and outputs/ has a similar structure.
data-analyst-harness/
├── HARNESS.md
├── tools/
│ ├── TOOLS.md
│ ├── database/
│ │ ├── TOOLS.md
│ │ ├── query-database/
│ │ │ ├── SKILL.md
│ │ │ ├── scripts/
│ │ │ └── references/
│ │ └── write-database/
│ │ ├── SKILL.md
│ │ └── scripts/
│ ├── files/
│ │ ├── TOOLS.md
│ │ ├── read-spreadsheet/
│ │ │ ├── SKILL.md
│ │ │ └── scripts/
│ │ ├── read-csv/
│ │ │ ├── SKILL.md
│ │ │ └── scripts/
│ │ └── read-json/
│ │ ├── SKILL.md
│ │ └── scripts/
│ ├── compute/
│ │ ├── TOOLS.md
│ │ ├── run-python/
│ │ │ ├── SKILL.md
│ │ │ └── scripts/
│ │ └── run-sql/
│ │ ├── SKILL.md
│ │ └── scripts/
│ └── external/
│ ├── TOOLS.md
│ ├── call-rest-api/
│ │ ├── SKILL.md
│ │ └── scripts/
│ └── fetch-warehouse/
│ ├── SKILL.md
│ └── scripts/
├── data/
│ ├── DATA.md
│ ├── relational/
│ │ ├── DATA.md
│ │ ├── schema-overview.md
│ │ ├── table-relationships.md
│ │ └── field-definitions.md
│ ├── warehouse/
│ │ ├── DATA.md
│ │ ├── dataset-catalog.md
│ │ └── partition-strategy.md
│ └── quirks/
│ ├── DATA.md
│ ├── known-data-quirks.md
│ └── null-handling.md
└── outputs/
├── OUTPUTS.md
├── visual/
│ ├── OUTPUTS.md
│ ├── generate-chart/
│ │ ├── SKILL.md
│ │ └── scripts/
│ └── generate-table/
│ ├── SKILL.md
│ └── scripts/
├── written/
│ ├── OUTPUTS.md
│ ├── write-summary/
│ │ └── SKILL.md
│ └── write-report/
│ └── SKILL.md
└── export/
├── OUTPUTS.md
├── export-csv/
│ ├── SKILL.md
│ └── scripts/
└── export-pdf/
├── SKILL.md
└── scripts/Like the agent skills standard, agent harnesses expects these files to have key markdown information to assist in routing decisions. HARNESS.md must have a name and description as key-value front matter along with the body, like so:
---
name: job-application-harness
description: Assists a job seeker through the full application workflow — from researching roles and companies through tailoring materials, tracking applications, and maintaining the harness.
---
This harness supports a job seeker managing an active job search. It covers researching target companies and roles, crafting and tailoring application materials, tracking the application pipeline, and maintaining the harness itself as the search evolves.
...Then the various routing files, like the TOOLS.md file discussed previously, must have a description along with a body.
---
description: Technical tools for DB admins, files, compute, and external integrations
---
- **database/** — Tools for interacting with the database
...This allows an agent to peek at these files before making a routing decision.
The practical result of the agent harnesses spec is that a harness ends up containing a fuzzy tree-like structure, where HARNESS.md is the root node, and various key markdown files can be used to encourage certain routing decisions as the agent propagates down the tree.
These files contain natural text and thus can reference anything, not only their children, allowing a harness to articulate the edge cases and nuances endemic to complex agentic problems.
A natural follow-up question is this: Where does a harness end?
You might want to define a harness that can explore every nuance of a codebase for helping developers work on code. In that case, every code file should be in the view of the harness.
However, if you have code that you’re happy with and you want to build a harness that helps non-technical people leverage that code, you might just want the harness to know that skills exist and not to explore beneath that level.
In a different example, you might imagine a large store of knowledge, which you’ve designed a specific skill to traverse. You might want to make it so the harness considers the large store of knowledge out of scope so that an agent is forced to use a tailored skill to access it.
To enable these types of use cases, the agent harnesses spec employs both a terminator document, .harnessleaf, and terminator patterns (like skill.md) to know when a folder should not be explored further. This allows developers to constrain where agents should explore, limiting their scope to what is necessary.
So that’s the agent harnesses standard. HARNESS.md, some intermediary markdown files for routing, and key files for terminating scope. The point isn’t to define a structure for its own sake, but to leverage this structure to make harnesses better. Let’s explore how we can use the agent harnesses “meta skill” to connect Claude with harnesses.
Using Agent Harnesses with Claude
The idea of the agent harnesses standard is that the authors of the agent, and the author of the harness, might agree on a shared upon specification.
However, agent harnesses is new, so Claude has no knowledge of the standard, it’s structure, or optimization around that standard. Thus I created the agent harnesses “metaskill”, which allows agents that don’t have native support for the agent harnesses standard, but do have support for skills, to understand agent harnesses. You can find the implementation of the agent harnesess metaskill here:
It essentially functions as an entry point into the agent harnesses standard, and has scripts and prompts that are optimized to guide an agent to efficiently leverage a standardized agent harness.
I’m still working on the metaskill, and improving it to deal with different harnesses, agentic clients, and applications. At its present, it has the following core functionality:
summarize.py — Briefly summarizes the project structure for an agent, so that it can quickly understand the harness and its contents.
disclose.py — Allows the agent to traverse through the harness via progressive disclosure to find resources relevant to a task
map_references.py — produces a structural overview of the harness, allowing the agent to view structural information at a glance
reverse_disclose.py — allows the agent to see routing documents before a given file, making maintenance of routing information more robust.
The skill also has a directory for exploration sessions, which allows an agent to keep track of how it’s explored a harness when trying to find specific information.
I plan on making agents that have native support for the agent harnesses spec in the near future, and I hope the standard proves useful enough that it might be adopted by popular agentic systems natively, but for now the metaskill is a convenient bridge that allows popular existing agents to use harnesses with a fair degree of robustness.
With the metaskill, we can now build a harness and use it with Claude.
Exploring a Job Application Assistant using Agent Harnesses
I’m working on a few example harnesses that explore how the agent harnesses standard can be employed to satisfy a variety of use cases. I’d like to take a moment to walk through one, a harness designed to assist people in finding a job.
It’s design operates under a fundamental ethos: AI agents are bad at writing, but they’re good at understanding large amounts of information and aligning that information towards a goal. Thus, the core of the system is the “tailor” skill, which tells the agent to look at existing resumes and use the information therein to create new resumes and cover letters tailored to a particular job posting.
Another fundamental idea is lead management. The harness maintains a leads.csv file that keeps track of job postings, the resumes tailored to them, their status, links, their level of priority based on user defined criteria, etc. The resume tailoring skill, and skills around exploring the internet to find new job postings, all use the leads.csv file as a central source of truth to coordinate searches and job applications.
It’s worth noting; if you look through the repo you won’t actually see leads.csv, nor resumes, job descriptions, etc. However, there are instructions on how to set these things up for a new user, which the harness has access to. Thus, when an agent loads the harness for the first time, it will help the user set up the requisite information.
To facilitate these various high-level workflows of finding jobs, writing resumes, and doing other supporting work, the harness has some functionality built into it. Notably in dealing with docx files
and a config file telling the agent to connect to playwright, which is an MCP server that allows for browser automation. This is necessary in viewing and confirming job listings.
{
“mcpServers”: {
“playwright”: {
“command”: “npx”,
“args”: [”@playwright/mcp@latest”]
}
}
}This convention is compatible with Claude. Similar files could be use to expose Playwright to agents like Cursor, Windsurf, and Codex.
If we clone this repo and navigate into the job-application-harness directory
git clone https://github.com/agentharnesses/exampleharnesses.git
cd exampleharnesses/job-application-harnesswe can go ahead and initialize claude.
danielwarfield@Mac job-application-harness % claude
╭─── Claude Code v2.1.191 ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ │ Tips for getting started │
│ Welcome back Daniel! │ Run /init to create a CLAUDE.md file with instructions for Claude │
│ │ ───────────────────────────────────────────────────────────────────────────────────────── │
│ ▐▛███▜▌ │ What’s new │
│ ▝▜█████▛▘ │ Added `/rewind` support for resuming a conversation from before `/clear` was run │
│ ▘▘ ▝▝ │ Fixed scroll position jumping to the bottom while reading earlier output during a stream… │
│ │ Fixed background agents resurrecting after being stopped — stopping an agent from the ta… │
│ Sonnet 4.6 · Claude Pro · Daniel Warfield │ /release-notes for more │
│ ~/…/exampleharnesses-fresh/job-application-harness │ │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
❯ Try “edit <filepath> to...”
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
? for shortcuts · ← for agents Recall, Claude has no understanding of the agent harnesses spec, nor of this harness in particular. This harness comes packaged with a pre-defined .claude directory which contains the metaskill, though, so we can fix both those issues by telling claude to load, load harness, initialize, or whatever.
after telling it to load, Claude uses the metaskill to get a summary of the harness structure
load the harness
⏺ Skill(agent-harnesses)
⎿ Successfully loaded skill
⏺ Let me start by summarizing the harness structure.
⏺ Bash(python
/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/.claude/skills/agent-harnesses/scripts/summarize.py
/Users/danielwa…)
⎿ job-application-harness/
├── [harness] HARNESS.md — Assists a job seeker through the full application workflo...
│
… +80 lines (ctrl+o to expand)It then realizes this is a new initialization, and decides to use the progressive-disclosure skill in the meta-skill to explore the harness to a greater degree of depth.
Now let me start a disclosure session and load the HARNESS.md to get the full context.
⏺ Bash(python
/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/.claude/skills/agent-harnesses/scripts/disclose.py
/Users/danielwar…)
⎿ {
“status”: “exploring”,
“session”: “8f15d70e”,
… +25 lines (ctrl+o to expand)
Read 1 file (ctrl+o to expand)
⏺ Bash(python
/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/.claude/skills/agent-harnesses/scripts/disclose.py
--session 8f15d7…)
⎿ {
“status”: “exploring”,
“session”: “8f15d70e”,
… +31 lines (ctrl+o to expand)
...I think the reason it’s doing progressive disclosure is to make sure it properly understands the repo. Specifically, it’s trying to understand that this is a fresh install. It doesn’t usually do this on a more fleshed out instance of the harness that has resumes, job listings, and other stuff.
Progressive disclosure takes time to run. If we wanted to discourage the agent from doing an exhaustive search on initialization, we could specify that in HARNESS.md to discourage that functionality.
...
# How to Find Information for Claude
Use the `agent-harnesses` skill to explore the harness. On initial load, run `summarize.py` to get a full picture of the harness structure — this is sufficient to understand what skills and references are available without needing a full disclosure session. Reserve `disclose.py` for when you need to read specific skill or reference content to act on a user request.
...Re-initializing a new session, we can see that Claude formed a high-level understanding of the repo in 14 seconds, without using progressive disclosure.
anielwarfield@Mac job-application-harness % claude
╭─── Claude Code v2.1.191 ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ │ Tips for getting started │
│ Welcome back Daniel! │ Run /init to create a CLAUDE.md file with instructions for Claude │
│ │ ───────────────────────────────────────────────────────────────────────────────────────── │
│ ▐▛███▜▌ │ What’s new │
│ ▝▜█████▛▘ │ Added `/rewind` support for resuming a conversation from before `/clear` was run │
│ ▘▘ ▝▝ │ Fixed scroll position jumping to the bottom while reading earlier output during a stream… │
│ │ Fixed background agents resurrecting after being stopped — stopping an agent from the ta… │
│ Sonnet 4.6 · Claude Pro · Daniel Warfield │ /release-notes for more │
│ ~/…/exampleharnesses-fresh/job-application-harness │ │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
❯ load
⏺ Skill(agent-harnesses)
⎿ Successfully loaded skill
⏺ Starting with a harness summary to get oriented.
⏺ Bash(python
/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/.claude/skills/agent-harnesses/scripts/summarize.py
/Users/danielwa…)
⎿ job-application-harness/
├── [harness] HARNESS.md — Assists a job seeker through the full application workflo...
│
… +80 lines (ctrl+o to expand)
⏺ The job-application-harness is loaded and ready. Here’s what’s available:
Skills:
- explore/find-listings — search for and source new job leads
- explore/job-description — load/scrape a job posting into the harness
- lead-management/apply — open a listing in the browser to submit an application
- lead-management/recommended-apply — pick the best lead to apply to next
- materials/answer — write answers to open-ended application questions
- materials/docx — create/edit Word documents (.docx)
- materials/tailor — tailor resume and cover letter to a specific job
References:
- references/setup.md — setup instructions for a fresh clone
- skills/explore/find-listings/references/currently-working-sources.md — notes from 68 leads collected as of 2026-06-24
What would you like to do?
✻ Cogitated for 14sIf we ask it a question, like how to get started, it will be able to quickly find and reference the correct source information.
❯ how do we get started?
⏺ Reading the setup instructions and harness root to give you an accurate answer.
Read 2 files (ctrl+o to expand)
⏺ Here’s what you need to do to get started:
1. Create references/leads.csv — the pipeline tracker:
company,job_title,posting_url,status,applied_date,resume_file,compensation,location,job_description_file
2. Create references/target-roles.md — your personal role profile. Suggested sections:
- What I’m Looking For
- Role Types (primary targets + acceptable alternatives, prioritized)
- Core Differentiators to Emphasize
- Industries / Companies
- What Makes a Strong Fit
- What to Avoid
3. Add a base resume template — copy your .docx resume into references/resumes/ as TEMPLATE_*.docx. The tailor skill uses this as the base for
all tailored resumes.
The three data directories (references/resumes/, references/job-descriptions/, references/answers/) already exist from the clone — no action
needed there.
Once those three files are in place, the full workflow is available: find listings → load job descriptions → tailor materials → apply.
Want help drafting target-roles.md, or do you have an existing resume to drop in first?
✻ Crunched for 9sI want it to go ahead and draft up something to get started.
❯ yeah draft up what you need.
⏺ Let me check what’s already in the repo before drafting anything.
Searched for 1 pattern (ctrl+o to expand)
⏺ Nothing exists yet beyond the empty directories. I need a few things from you to draft target-roles.md — the leads.csv I can create now since
it’s just a header row, but the role profile needs your input.
A few quick questions:
1. What roles are you targeting? (titles, seniority level — e.g. “Senior ML Engineer”, “Head of Data Science”)
2. What’s your background? (short version — what you’ve done, what makes you stand out)
3. Any industry preferences or hard avoids? (e.g. “prefer fintech, avoid defense”)
4. Location / remote preference?
The resume template I can’t generate — you’ll need to drop your .docx into references/resumes/ yourself. But I can create the CSV and a draft
target-roles.md as soon as I have the above.
✻ Cooked for 13sThe whole idea is that this system takes existing resumes and refines them, so instead of following these setup instructions, I’ll tell it my resume is in the downloads folder.
❯ my resume is in my downloads folder, use that.
Searched for 1 pattern (ctrl+o to expand)
⏺ Found it. Let me read it to understand your background before drafting the role profile.
⏺ Bash(python -c “
from docx import Document…)
⎿ Daniel Warfield
Austin, TX | hire@danielwarfield.dev
Website
… +43 lines (ctrl+o to expand)
⏺ Good picture of your background. Let me also check the tailor skill’s template requirements, then I’ll create everything at once.
Read 1 file (ctrl+o to expand)
⏺ The tailor skill expects a specific template file: TEMPLATE_DanielWarfield_Resume_cover.docx with a cover letter page prepended. Your Downloads
resume is the resume half — I’ll copy it over, but flagging now that you’ll need to add the cover letter page to it before the tailor skill
works end-to-end.
Creating the three files now:
⏺ Bash(cp “/Users/danielwarfield/Downloads/2026_04_17_DanielWarfield_Resume (1).docx”
“/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-ha…)
⎿ Done
⏺ Write(references/leads.csv)
⎿ Wrote 1 lines to references/leads.csv
1 company,job_title,posting_url,status,applied_date,resume_file,compensation,location,job_description_file
⏺ Write(references/target-roles.md)
⎿ Wrote 55 lines to references/target-roles.md
2 # Target Role Profile — Daniel Warfield
3 ## What I’m Looking For
4
5 Senior technical roles at the intersection of AI/ML and product delivery — where I can own meaningful systems end to end, drive re
venue outcomes, and operate with autonomy. The sweet spot is hands-on technical leadership: still building, but shaping direction
6 and managing delivery.
7 ## Role Types
8
9 **Primary targets (in priority order):**
10 1. Technical Lead / Principal Engineer — AI/ML, agentic systems, or LLM infrastructure
… +47 lines (ctrl+o to expand)
⏺ Done. Here’s what was created:
┌──────────────────────────────────────────────────────────────┬──────────────────────────────────────────────┐
│ File │ Status │
├──────────────────────────────────────────────────────────────┼──────────────────────────────────────────────┤
│ references/leads.csv │ Created with header row, ready for leads │
├──────────────────────────────────────────────────────────────┼──────────────────────────────────────────────┤
│ references/target-roles.md │ Drafted from your resume — review and adjust │
├──────────────────────────────────────────────────────────────┼──────────────────────────────────────────────┤
│ references/resumes/TEMPLATE_DanielWarfield_Resume_cover.docx │ Copied from Downloads │
└──────────────────────────────────────────────────────────────┴──────────────────────────────────────────────┘
One thing to follow up on: The tailor skill expects the template to have a cover letter page prepended with specific paragraph IDs
(00000004–0000000C). Right now the template is just your resume. Before you tailor materials for the first time, that cover letter structure
needs to be added to the template. We can tackle that when you’re ready to tailor.
Take a look at target-roles.md and let me know what to adjust — I made some assumptions about role priorities and company stage preferences.
✻ Brewed for 1m 5sAnd, now that it has an idea of what jobs I’m looking for, I can have it scan around for some jobs.
❯ Find five jobs
Read 2 files (ctrl+o to expand)
⏺ Running parallel searches across high-signal sources now.
⏺ Web Search(”site:builtinaustin.com “AI engineer” OR “ML engineer” OR “technical lead” 2026”)
⏺ Web Search(”site:builtinaustin.com “director of engineering” OR “head of AI” OR “staff engineer” AI”)
Web Search(”site:job-boards.greenhouse.io “machine learning” OR “AI engineer” Austin OR remote 2026”)
⏺ Web Search(”site:builtinaustin.com “director of engineering” OR “head of AI” OR “staff engineer” AI”)
⎿ Did 1 search in 8s
⏺ Web Search(”site:job-boards.greenhouse.io “machine learning” OR “AI engineer” Austin OR remote 2026”)
⎿ Did 1 search in 8s
⏺ Web Search(”site:ashbyhq.com “technical lead” OR “staff engineer” OR “principal engineer” AI OR LLM”)
⎿ Did 1 search in 10s
⏺ Web Search(”site:wellfound.com “AI engineer” OR “ML engineer” Austin OR remote senior 2026”)
⎿ Did 1 search in 8s
⏺ Good haul. Filtering and ranking against your profile now.
Here are the top 5 candidates:
---
Technical Lead / Staff / Principal — AI
1. TRM Labs — Staff Software Engineer, Agent Engineering (US Remote)
Fraud/compliance tech company building LLM-powered agentic systems — direct overlap with FraudX. Staff level with real ownership.
https://jobs.ashbyhq.com/trm-labs/eb560943-3adb-4839-bf64-4cbdeee9ae57
2. Hippocratic AI — Senior Staff AI Engineer (Remote)
Sets direction across RAG, agent orchestration, evaluation, real-time voice, and safety. Matches almost every line of your resume —
observability, agentic design, LLM eval.
https://jobs.ashbyhq.com/Hippocratic%20AI/af39c865-a9ab-403e-8746-79dec87d6ad0
3. Glean — ML Engineer, AI Assistant & Autonomous AI Agents (Remote)
Enterprise AI search platform, autonomous agents focus. Well-funded, high technical bar.
https://job-boards.greenhouse.io/gleanwork/jobs/4605215005
---
Director / Head of Engineering
4. SEON — Director of Engineering (Austin/Remote)
Fraud detection SaaS — directly adjacent to FraudX. Director-level, manages engineering strategy and teams. ⚠️ SEON is mid-size; worth checking
comp.
https://www.builtinaustin.com/job/director-engineering/9615304
5. Dropbox — Director of Engineering, New AI Initiatives (Remote)
Leading new AI productivity initiatives, people management + technical direction. Large-company autonomy risk, but strong brand and likely
strong comp.
https://www.builtinaustin.com/job/engineer/director-engineering-new-ai-initiatives/135271
---
Which of these would you like to add to the pipeline?It knows I’m based out of Austin, and it’s referencing the file
skills/explore/find-listings/references/currently-working-sources.md
to prioritize certain websites. If I give the harness high-level information like “I’m moving to California, change the harness accordingly,” it can update the relevant content because it has a strong idea of what information exists and where it exists.
❯ I’m moving to California, change the harness accordingly
⏺ Two files need updating: target-roles.md (Austin comp reference) and currently-working-sources.md (builtinaustin.com is the wrong surface now).
⏺ Update(references/target-roles.md)
⎿ Added 1 line, removed 1 line
44 - Company is past “can we use AI?” and into “how do we scale this?”
45 - Technical bar is high; teammates I’d learn from
46 - Problem space I’d want to write or talk about publicly
47 -- Compensation competitive with Austin/remote senior IC or director market
47 +- Compensation competitive with California/remote senior IC or director market
48
49 ## What to Avoid
50
Read 1 file (ctrl+o to expand)
⏺ Update(skills/explore/find-listings/references/currently-working-sources.md)
⎿ Added 5 lines, removed 5 lines
4
5 ## High Signal
6
7 -**builtinaustin.com**
8 -- Best discovery surface for Austin-specific and Austin-remote roles
9 -- Reliable location filtering — rarely surfaces SF-only or NYC-only postings labeled as Austin
10 -- Two search waves (16 candidates total) had ~87% signal rate (14/16 active, 2 expired)
11 -- Use queries like: `site:builtinaustin.com “AI engineer” OR “ML engineer”`, `site:builtinaustin.com “solutions architect” AI`
7 +**builtinsf.com / builtinla.com**
8 +- builtinaustin.com was previously high signal (87% rate over 68 leads) but is no longer the target market — user has moved to Ca
+lifornia
9 +- builtinsf.com covers the Bay Area; builtinla.com covers LA — use both depending on target sub-region
10 +- Expect similar signal quality to builtinaustin.com; location filtering is reliable across Built In sites
11 +- Use queries like: `site:builtinsf.com “AI engineer” OR “ML engineer”`, `site:builtinla.com “technical lead” AI`
12 - Compensations are usually present and accurate
13
14 **Direct company career pages**
⏺ Update(skills/explore/find-listings/references/currently-working-sources.md)
⎿ Added 2 lines, removed 2 lines
22 **Greenhouse (greenhouse.io / job-boards.greenhouse.io)**
23 - Reliable for mid-size and larger startups (Anthropic, Hightouch, LaunchDarkly, Avride, Apptronik)
24 - Direct ATS URLs don’t expire as fast as aggregator mirrors
25 -- Use: `site:job-boards.greenhouse.io “machine learning” OR “AI engineer” Austin OR remote`
25 +- Use: `site:job-boards.greenhouse.io “machine learning” OR “AI engineer” California OR remote`
26
27 **Ashby (ashbyhq.com / jobs.ashbyhq.com)**
28 - Strong coverage of frontier AI and well-funded startups (Baseten, Cognition, H Company, webAI, Writer, Cohere, Eigen Labs)
...
31 **Workday (myworkdayjobs.com)**
32 - Covers larger enterprises (NVIDIA, Guidewire, CrowdStrike, Zoom)
33 - Postings tend to stay live longer than aggregators
34 -- Hard to search directly; best reached via Google: `site:myworkdayjobs.com “AI” Austin OR remote`
34 +- Hard to search directly; best reached via Google: `site:myworkdayjobs.com “AI” California OR remote`
35
36 ## Low Signal — Use Sparingly
37
⏺ Update(skills/explore/find-listings/references/currently-working-sources.md)
⎿ Added 1 line, removed 1 line
41 - Avoid unless testing a very specific query
42
43 **Lever (lever.co / jobs.lever.co)**
44 -- 4 leads collected; 2 expired before application, 1 non-Austin, 1 applied (Palantir)
44 +- 4 leads collected; 2 expired before application, 1 non-California, 1 applied (Palantir)
45 - Higher expiration rate than Greenhouse or Ashby
46 - Still worth including in parallel searches but don’t over-index
47
⏺ Update(skills/explore/find-listings/references/currently-working-sources.md)
⎿ Added 2 lines, removed 2 lines
49
50 **LinkedIn Jobs**
51 - Not yet used; likely largest volume for established companies
52 -- Austin + Remote filter is reliable
52 +- California + Remote filter is reliable
53 - Best for: Microsoft, Meta, Snowflake, Confluent, Anyscale, and other large-company ML/AI roles
54 -- Query shape: search LinkedIn Jobs for “machine learning engineer” or “solutions architect AI” in Austin TX or Remote
54 +- Query shape: search LinkedIn Jobs for “machine learning engineer” or “solutions architect AI” in California or Remote
55
56 **Wellfound (wellfound.com, formerly AngelList)**
57 - Not yet used; strong coverage of funded AI startups
⏺ Done. Changes made:
- references/target-roles.md — comp benchmark updated from Austin to California market
- skills/explore/find-listings/references/currently-working-sources.md — replaced builtinaustin.com with builtinsf.com / builtinla.com, updated
all Austin location references to California throughout
One thing I didn’t touch: your resume still says “Austin, TX” — you’ll want to update that before tailoring materials. Want me to do that now?This isn’t foolproof, admittedly, but the structure imposed by agent harnesses makes these types of general edits both more reliable, and makes fixing issues around partial or incomplete edits more consistent. Paired with Claud’s implicit abilities to maintain complex code bases, misalignments between different documents are easily resolved.
❯ ensure that all localtion references align across the harness
Searched for 1 pattern, read 1 file (ctrl+o to expand)
⏺ Three changes needed in recommended-apply/SKILL.md: the status soft-note example, the location ranking criterion, and the example output.
⏺ Update(skills/lead-management/recommended-apply/SKILL.md)
⎿ Added 1 line, removed 1 line
15
16 ## Step 2: Filter to Pending Leads
17
18 -A lead is pending if its `status` field is blank, or contains a soft note like “Verify Austin availability” or “Verify remote ava
-ilability”. Exclude any lead where status is one of:
18 +A lead is pending if its `status` field is blank, or contains a soft note like “Verify California availability” or “Verify remote
+ availability”. Exclude any lead where status is one of:
19
20 - `Applied` (any variant, including “Applied - ...”)
21 - `No Interview`
⏺ Update(skills/lead-management/recommended-apply/SKILL.md)
⎿ Added 1 line, removed 1 line
28 Score each pending lead against the criteria in `target-roles.md`. In priority order:
29
30 1. **Role type** — ML/AI Engineer scores highest; FDE/Solutions Architect is acceptable; SA/PM are lower
31 -2. **Location** — Austin TX (on-site or hybrid) > Fully Remote > Out-of-state on-site
31 +2. **Location** — California (on-site or hybrid) > Fully Remote > Out-of-state on-site
32 3. **Company quality** — Large established company or well-known funded startup > smaller/earlier stage
33 4. **Technical fit** — Agentic AI, production ML, LLMs, end-to-end ownership match the background best
34 5. **Interest signal** — Robotics, frontier AI labs, and novel problem spaces rank up
⏺ Update(skills/lead-management/recommended-apply/SKILL.md)
⎿ Added 4 lines, removed 4 lines
46 ```
47 My recommendation:
48
49 -1. **Cognite — ML Engineer, Atlas AI** (Austin TX)
50 - Best available Austin ML engineer role — LLM agents + RAG, strong company fit.
49 +1. **Cognite — ML Engineer, Atlas AI** (California)
50 + Best available California ML engineer role — LLM agents + RAG, strong company fit.
51
52 -2. **Avride — Machine Learning Engineer** (Austin TX)
53 - Autonomous driving perception + LLMs, well-funded, Austin.
52 +2. **Avride — Machine Learning Engineer** (California)
53 + Autonomous driving perception + LLMs, well-funded, California.
54
55 3. **Cohere — Applied AI Engineer, Agentic Workflows** (Remote)
56 Top-tier AI lab, pure ML engineering, agentic pipelines — best remote option.
⏺ Now fix the remaining “BuiltIn Austin” reference in the sources file:
⏺ Update(skills/explore/find-listings/references/currently-working-sources.md)
⎿ Added 1 line, removed 1 line
56 **Wellfound (wellfound.com, formerly AngelList)**
57 - Not yet used; strong coverage of funded AI startups
58 - Many frontier AI companies appear here before BuiltIn or Greenhouse
59 -- Good complement to BuiltIn Austin for startup-tier leads
59 +- Good complement to BuiltIn SF/LA for startup-tier leads
60
61 **Direct pages not yet checked**
62 Companies in the target profile tier that haven’t been sourced yet:
⏺ Let me do a final check to confirm nothing was missed:
Searched for 1 pattern (ctrl+o to expand)
⏺ Clean. All location references across the harness now point to California. Files updated:
- references/target-roles.md — comp benchmark
- skills/explore/find-listings/references/currently-working-sources.md — builtinaustin → builtinsf/builtinla, all query examples
- skills/lead-management/recommended-apply/SKILL.md — status soft-note, location ranking criterion, example output
Your resume still says “Austin, TX” — that’s outside the harness but worth updating before you apply anywhere.
✻ Baked for 38sFor big changes that fundamentally change the structure of the harness itself, the metaskill should invoke reverse_disclose.py, allowing the agent to quickly find key resources that need to be modified. Unfortunately, because Claud doesn’t natively understand the agent harnesses standard, it doesn’t know about its structure and may not think to invoke reverse disclosure on its own. So, you might have to give it some hints up front to use tooling in the harness to assist in maintenance.
❯ get rid of the resumes directory. I want all resumes to be generated on the fly. Follow harness maintinance.
⏺ Following harness maintenance — running reverse disclosure on the resumes directory first to find every routing file that references it.
⏺ Bash(python /Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/.claude/skills/agent-harnesses/scripts/reverse
_disclose.py /Users/d…)
⎿ {
“status”: “complete”,
“target”: “references/resumes”,
… +12 lines (ctrl+o to expand)
⏺ Two routing files to update: REFERENCES.md and HARNESS.md. I already know the skill files that reference resumes/ from my earlier grep. Now I’ll
make all changes, then move the template and delete the directory.
Read 4 files (ctrl+o to expand)
⏺ Now I have everything I need. Making all changes in parallel:
⏺ Update(references/REFERENCES.md)
⎿ Added 2 lines, removed 1 line
5 - **setup.md** — Setup instructions for a freshly cloned repo: what files and directories to create before the harness is usable
6 - **leads.csv** — Application pipeline tracker: company, role, posting URL, status, applied date, resume used, compensation, loca
tion
7 - **job-descriptions/** — Saved job postings, one markdown file per role. Used as input for tailoring materials and assessing fit
.
8 -- **resumes/** — Tailored resumes, one per target role or application
8 +- **background.md** — Canonical work history and competencies pool; read by the tailor skill to generate resumes on the fly
9 +- **TEMPLATE_DanielWarfield_Resume_cover.docx** — Base .docx template used by the tailor skill for all generated resumes
10 - **answers/** — Saved responses to application questions, including standard fields (name, email, phone, location, LinkedIn) and
open-ended responses. Used as source material for future applications.
11 - **target-roles.md** — Profile of target roles, preferred industries, company size, and criteria for evaluating fit
⏺ Update(HARNESS.md)
⎿ Added 2 lines, removed 1 line
25
26 - **leads.csv** — Application pipeline tracker (company, role, posting, status, applied date, resume, compensation, location). **
When an application is submitted, the `status` and `applied_date` columns must be filled in immediately** — blank status means pe
nding, so an un-updated row will be re-recommended as a lead.
27 - **job-descriptions/** — Saved job postings in markdown, used as input for tailoring materials and fit assessment
28 -- **resumes/** — Tailored resumes, one per target role or application
28 +- **background.md** — Canonical work history and competencies pool; source of truth for all generated application materials
29 +- **TEMPLATE_DanielWarfield_Resume_cover.docx** — Base .docx template used for all generated resumes
30 - **answers/** — Saved responses to application questions, including standard fields (name, email, phone, location, LinkedIn) and
open-ended responses. Used as source material for future applications.
31 - **target-roles.md** — Profile of target roles, industries, and criteria for a good fit
⏺ Update(references/setup.md)
⎿ Added 1 line, removed 1 line
8
9 ## Directories
10
11 -The three reference directories (`resumes/`, `job-descriptions/`, `answers/`) are preserved in git via `.gitkeep` files and will
-exist immediately after cloning. No action needed.
11 +The two reference directories (`job-descriptions/`, `answers/`) are preserved in git via `.gitkeep` files and will exist immediat
+ely after cloning. No action needed.
12
13 ## Files to Create
14
⏺ Update(references/setup.md)
⎿ Added 2 lines, removed 2 lines
34 - **What Makes a Strong Fit** — specific signals to look for
35 - **What to Avoid** — hard or soft exclusions
36
37 -### `references/resumes/TEMPLATE_*.docx`
37 +### `references/TEMPLATE_DanielWarfield_Resume_cover.docx`
38
39 -The tailor skill uses a template `.docx` file as the base for all new resumes. Copy your base resume template into `references/re
-sumes/` before tailoring any materials. The template must match the paraId structure expected by the tailor skill — see `skills/m
-aterials/tailor/SKILL.md` for the required section IDs.
39 +The tailor skill uses this template `.docx` file as the base for all generated resumes. Copy your base resume template here befor
+e tailoring any materials. The template must match the paraId structure expected by the tailor skill — see `skills/materials/tail
+or/SKILL.md` for the required section IDs.
⏺ Update(skills/materials/tailor/SKILL.md)
⎿ Added 3 lines, removed 9 lines
11
12 Before starting, confirm you have:
13 - The job listing (pasted text or URL)
14 -- Access to existing resumes in `references/resumes/`
14 +- Access to `references/background.md`
15
16 If the job listing needs to be fetched and the page is JavaScript-rendered (WebFetch returns only the title), do not ask the user
to paste it. Instead, provide the posting URL from `leads.csv` so the user can open it themselves and paste the text.
17
18 -Read **every** resume in `references/resumes/` before drafting anything — not just the most obviously relevant ones. All existing
- resumes are approved and contain valid source material; the goal is to find the best language for each point across the full set
-. Convert all of them in parallel with `pandoc`:
18 +Read `references/background.md` before drafting anything. It contains the canonical work history, bullets, and competencies pool
+— all source material for generated resumes. Do not invent content not present there.
19
20 -```bash
21 -ls references/resumes/*.docx | grep -v TEMPLATE | xargs -I{} bash -c ‘pandoc --track-changes=all “{}” -o “/tmp/$(basename “{}” .d
-ocx).md”’
22 -```
20 +When producing a new docx, always use `references/TEMPLATE_DanielWarfield_Resume_cover.docx` as the base. It has the correct form
+atting, page break, and structure. Replace only the `<w:t>` text nodes — do not rebuild runs or paragraphs. The paraIds for varia
+ble sections are:
21
24 -Then read all the converted markdown files before proceeding.
25 -
26 -When producing a new docx, always use `references/resumes/TEMPLATE_DanielWarfield_Resume_cover.docx` as the base. It has the corr
-ect formatting, page break, and structure. Replace only the `<w:t>` text nodes — do not rebuild runs or paragraphs. The paraIds f
-or variable sections are:
27 -
22 | Section | ParaIds |
23 |---|---|
24 | Cover letter opening | `00000004` |
⏺ Update(skills/materials/tailor/SKILL.md)
⎿ Added 3 lines, removed 3 lines
59 **Core content:** Keep the work history, project descriptions, and accomplishments the same. Do not invent new bullets.
60
61 **What to vary across versions:**
62 -- **Core competencies** — select and reorder from across all existing resumes to match what the listing emphasizes. Keep each com
-petency string to **30 characters or fewer** — the resume renders them in a 3-column layout and longer strings wrap, adding heigh
-t that pushes content to a third page.
63 -- **Skills / Tools** — pull from whichever existing resume frames the most relevant tools. Update the list to reflect both real e
-xperience and what the listing calls out.
64 -- **Framing** — where multiple resumes describe the same role differently, choose the framing that best aligns with the listing’s
- language.
62 +- **Core competencies** — select and reorder from the competencies pool in `references/background.md` to match what the listing e
+mphasizes. Keep each competency string to **30 characters or fewer** — the resume renders them in a 3-column layout and longer st
+rings wrap, adding height that pushes content to a third page.
63 +- **Skills / Tools** — pull from the skills listed in `references/background.md`. Update the list to reflect both real experience
+ and what the listing calls out.
64 +- **Framing** — where the background document offers multiple ways to describe a role, choose the framing that best aligns with t
+he listing’s language.
65
66 ## Output Format
67
⏺ Update(skills/materials/answer/SKILL.md)
⎿ Added 1 line, removed 1 line
21 - **Theme overlap** — does the existing answer address the same underlying capability (e.g., data pipelines, safety-critical depl
oyment, evaluation systems, stakeholder communication)?
22 - **Language reuse potential** — are there sentences or phrases that can be carried over with minimal change?
23
24 -If no existing answers are relevant, fall back to the resume content in `references/resumes/` using the same approach as the tail
-or skill.
24 +If no existing answers are relevant, fall back to `references/background.md` using the same approach as the tailor skill.
25
26 ## Step 3: Draft the Answer
27
⏺ Update(skills/lead-management/apply/SKILL.md)
⎿ Added 1 line, removed 1 line
15
16 Read `references/leads.csv` and find the matching row. Extract:
17 - `posting_url` — the job listing URL to open
18 -- `resume_file` — relative path to the tailored resume (e.g., `resumes/19_webAI_FDE_DanielWarfield_Resume_cover.docx`)
18 +- `resume_file` — relative path to the generated resume (e.g., `19_webAI_FDE_DanielWarfield_Resume_cover.docx`)
19
20 If `resume_file` is blank, warn the user that no resume is on file for this role and ask whether to proceed without one or run th
e tailor skill first.
21
⏺ Now move the template and delete the directory:
⏺ Bash(mv “/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/references/resumes/TEMPLATE_DanielWarfield_Resume
_cover.docx” “/Users/…)
⎿ Done
⏺ Now verify with reverse disclosure that background.md and the template are correctly referenced:
⏺ Bash(python /Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/.claude/skills/agent-harnesses/scripts/reverse
_disclose.py /Users/d…)
⎿ {
“status”: “complete”,
“target”: “references/background.md”,
… +30 lines (ctrl+o to expand)
⏺ Both are correctly referenced. Final sanity check — no stale resumes/ references anywhere:
Searched for 1 pattern (ctrl+o to expand)
⏺ One stale reference in README.md:
Read 1 file (ctrl+o to expand)
⏺ Update(README.md)
⎿ Added 1 line, removed 1 line
27
28 - `references/leads.csv` — pipeline tracker (see `references/setup.md` for the header row)
29 - `references/target-roles.md` — your role profile, used to rank and recommend leads
30 -- `references/resumes/TEMPLATE_*.docx` — your base resume template
30 +- `references/TEMPLATE_*.docx` — your base resume template
31
32 See `references/setup.md` for full setup instructions.
33
⏺ Clean. Here’s what changed:
- Deleted references/resumes/ directory
- Moved template to references/TEMPLATE_DanielWarfield_Resume_cover.docx
- references/background.md — canonical content source, wired into routing
- tailor/SKILL.md — reads background.md instead of scanning stored resumes; updated template path
- answer/SKILL.md — fallback updated to background.md
- apply/SKILL.md — example path updated
- REFERENCES.md, HARNESS.md, setup.md, README.md — all routing and docs updated, no stale paths remaining
✻ Baked for 1m 54sThis issue of needing to say “make sure you do this”, “don’t forget to do that”, is a problem that the agent harnesses standard is attempting to solve. Without native integration into agentic clients, though, there will need to be some manual effort on the part of the user.
Now that we just changed how the harness fundamentally works, we can generate some materials to apply to some jobs and see what we get.
❯ looks good, make a resume
⏺ Which one — TRM Labs, Hippocratic AI, or SEON?
✻ Cooked for 8s
❯ all three
Read 1 file (ctrl+o to expand)
⏺ The approach is: unpack the template, edit the XML paragraphs at the known paraIds, repack as three separate files. Let me check the scripts
exist first, then unpack.
Searched for 1 pattern, listed 1 directory (ctrl+o to expand)
⏺ Scripts are in skills/materials/docx/scripts/office/. Unpacking the template now to inspect its structure.
⏺ Bash(python skills/materials/docx/scripts/office/unpack.py references/TEMPLATE_DanielWarfield_Resume_cover.docx
/private/tmp/claude-501/-Users-danielwarfield-Documen…)
⎿ Unpacked references/TEMPLATE_DanielWarfield_Resume_cover.docx (15 XML files), simplified 0 tracked changes, merged 0 runs
Searched for 2 patterns (ctrl+o to expand)
⏺ The template is the plain resume (no cover letter page yet). Let me see the full structure before proceeding.
Searched for 1 pattern (ctrl+o to expand)
⏺ The template is a plain resume — no cover letter page yet. I have the full paraId map. Writing a generation script to produce all three .docx
files with tailored competencies and updated location.
⏺ Write(/private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d26-1a58-4195-af1f-2d40
40537723/scratchpad/generate_resumes.py)
⎿ Wrote 134 lines to ../../../../../../private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-applicatio
n-harness/b6cf4d26-1a58-4195-af1f-2d4040537723/scratchpad/generate_resumes.py
2 import osutil
3 import re
4 import subprocess
5
6 scratchpad = “/private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d
26-1a58-4195-af1f-2d4040537723/scratchpad”
7 template_dir = scratchpad + “/template_unpacked”
8 harness = “/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness”
9
10 # competency paraIds in table order (positions 1-9)
… +125 lines (ctrl+o to expand)
⏺ Bash(python /private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d26-1a58-4195-af1
f-2d4040537723/scratc…)
⎿ Error: Exit code 1
Generating TRMLabs...
Traceback (most recent call last):
File “/private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d26-1a58-4195-af1f
-2d4040537723/scratchpad/generate_resumes.py”, line 118, in <module>
result = subprocess.run(
[”python”,
...<3 lines>...
capture_output=True, text=True
)
… +16 lines (ctrl+o to expand)
⏺ Bash(python3 /private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d26-1a58-4195-af
1f-2d4040537723/scrat…)
⎿ Error: Exit code 1
Generating TRMLabs...
Traceback (most recent call last):
File “/private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d26-1a58-4195-af1f
-2d4040537723/scratchpad/generate_resumes.py”, line 118, in <module>
result = subprocess.run(
[”python”,
...<3 lines>...
capture_output=True, text=True
)
… +16 lines (ctrl+o to expand)
⏺ Update(/private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d26-1a58-4195-af1f-2d4
040537723/scratchpad/generate_resumes.py)
⎿ Added 1 line, removed 1 line
116
117 output_path = f”{harness}/references/{config[’filename’]}”
118 result = subprocess.run(
119 - [”python”,
119 + [”python3”,
120 f”{harness}/skills/materials/docx/scripts/office/pack.py”,
121 work_dir, output_path,
122 “--original”, f”{harness}/references/TEMPLATE_DanielWarfield_Resume_cover.docx”],
⏺ Bash(python3 /private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d26-1a58-4195-af
1f-2d4040537723/scrat…)
⎿ Generating TRMLabs...
OK: /Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/references/TRMLabs_DanielWarfield_Resume_202
6-06-25.docx
… +13 lines (ctrl+o to expand)
⏺ All three built. Now verifying page counts and updating leads.csv.
⏺ Bash(for f in TRMLabs HippocraticAI SEON; do
bash /Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/skills/materials/tailor/scr…)
⏺ Bash(python3 /private/tmp/claude-501/-Users-danielwarfield-Documents-GitHub-exampleharnesses-fresh-job-application-harness/b6cf4d26-1a58-4195-af
1f-2d4040537723/scrat…)
⎿ Generating TRMLabs...
OK: /Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/references/TRMLabs_DanielWarfield_Resume_202
6-06-25.docx
… +13 lines (ctrl+o to expand)
⏺ All three built. Now verifying page counts and updating leads.csv.
⏺ Bash(for f in TRMLabs HippocraticAI SEON; do
bash /Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/skills/materials/tailor/scr…)
⎿ 2
TRMLabs: OK
2
… +3 lines (ctrl+o to expand)
⏺ All three are exactly 2 pages. Updating leads.csv with the file paths.
⏺ Write(references/leads.csv)
⎿ Added 3 lines, removed 3 lines
1 company,job_title,posting_url,status,applied_date,resume_file,compensation,location,job_description_file
2 -TRM Labs,Staff Software Engineer - Agent Engineering,https://jobs.ashbyhq.com/trm-labs/eb560943-3adb-4839-bf64-4cbdeee9ae57,,,,,$2
-00k-$275k,Remote,job-descriptions/TRMLabs_staff-swe-agent-engineering_2026-06-25.md
3 -Hippocratic AI,Senior Staff AI Engineer,https://jobs.ashbyhq.com/Hippocratic%20AI/af39c865-a9ab-403e-8746-79dec87d6ad0,,,,, Palo A
-lto (in-office),job-descriptions/HippocraticAI_senior-staff-ai-engineer_2026-06-25.md
2 +TRM Labs,Staff Software Engineer - Agent Engineering,https://jobs.ashbyhq.com/trm-labs/eb560943-3adb-4839-bf64-4cbdeee9ae57,,,TRML
+abs_DanielWarfield_Resume_2026-06-25.docx,$200k-$275k,Remote,job-descriptions/TRMLabs_staff-swe-agent-engineering_2026-06-25.md
3 +Hippocratic AI,Senior Staff AI Engineer,https://jobs.ashbyhq.com/Hippocratic%20AI/af39c865-a9ab-403e-8746-79dec87d6ad0,,,Hippocrat
+icAI_DanielWarfield_Resume_2026-06-25.docx,,Palo Alto (in-office),job-descriptions/HippocraticAI_senior-staff-ai-engineer_2026-06-
+25.md
4 Glean,Machine Learning Engineer - AI Assistant & Autonomous AI Agents,https://job-boards.greenhouse.io/gleanwork/jobs/4605215005,,
,,,Remote,
5 -SEON,Director of Engineering,https://www.builtinaustin.com/job/director-engineering/9615304,,,,, Austin Hybrid,job-descriptions/SE
-ON_director-engineering_2026-06-25.md
5 +SEON,Director of Engineering,https://www.builtinaustin.com/job/director-engineering/9615304,,,SEON_DanielWarfield_Resume_2026-06-2
+5.docx,,Austin Hybrid,job-descriptions/SEON_director-engineering_2026-06-25.md
6 Dropbox,Director of Engineering - New AI Initiatives,https://www.builtinaustin.com/job/engineer/director-engineering-new-ai-initia
tives/135271,,,,,Remote,
⏺ Opening all three in LibreOffice for review.
⏺ Bash(open -a “LibreOffice” \
“/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/references/TRMLabs_DanielWarfield_Resume_2026-0…)
⎿ Waiting…
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
5 -SEON,Director of Engineering,https://www.builtinaustin.com/job/director-engineering/9615304,,,,, Austin Hybrid,job-descriptions/SE
-ON_director-engineering_2026-06-25.md
5 +SEON,Director of Engineering,https://www.builtinaustin.com/job/director-engineering/9615304,,,SEON_DanielWarfield_Resume_2026-06-2
+5.docx,,Austin Hybrid,job-descriptions/SEON_director-engineering_2026-06-25.md
⏺ Bash(open -a “LibreOffice” \
“/Users/danielwarfield/Documents/GitHub/exampleharnesses-fresh/job-application-harness/references/TRMLabs_DanielWarfield_Resume_2026-0…)
⎿ (No output)
⏺ All three resumes are generated and open in LibreOffice. Each is exactly 2 pages with:
- Location updated to “California” throughout
- Tailored competencies for the role
- Full work history unchanged
leads.csv has been updated with the resume file paths for TRM Labs, Hippocratic AI, and SEON. Take a look and let me know if anything needs
adjusting.
✻ Crunched for 3m 21s
※ recap: Job search harness set up and three tailored resumes generated for TRM Labs, Hippocratic AI, and SEON. Review the open LibreOffice docs
and say if anything needs adjusting before applying.I want to zoom out a little bit. By saying the following commands over the course of a few minutes:
> load
> how do we get started?
> yeah draft up what you need.
> my resume is in my downloads folder, use that.
> Find five jobs
> I’m moving to California, change the harness accordingly
> ensure that all localtion references align across the harness
> get rid of the resumes directory. I want all resumes to be generated on the fly. Follow harness maintinance.
> apply to something
> yeah add those to the pipeline and apply
> make a resume for all three
> looks good, make a resume
> all three The harness
makes itself understood by the agent
initialized itself with the relevant information to get started
allowed the user to change key information across the harness
allowed the user to fundamentally changed a core aspect of how the harness operated
found five jobs online that align with my experience
downloaded the job descriptions of those listings
drafted a resume tailored for those jobs in text
after confirming, created the resumes themselves as docx files
et voila, it makes me three resumes.
If you look at these resumes, they’re not perfect. It moved some of my experience over to California, which is a bit of an odd design choice. Recall that I told the harness to re-work itself to generate resumes on the fly rather than using a template. I did this to demonstrate how the harness can maintain itself, but the original approach of the harness using and refining a template file alleviates these types of issues.
Despite its flaws, if I really wanted to maintain this new paradigm, I can use the harness to help me figure out exactly what needs to change.
❯ I don’t like some of the aspects of the final resumes. What should I modify in the harness to make the output better?
⏺ What specifically don’t you like? The answer depends on which part of the output is wrong:
┌─────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ If you dislike... │ Change this │
├─────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ The competencies chosen │ references/background.md — tighten the competency pool, or add guidance to skills/materials/tailor/SKILL.md │
│ │ on how to rank them │
├────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ The bullet text / phrasing │ references/background.md — rewrite the bullets directly; that’s the source of truth │
├────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ The professional summary │ references/background.md — it’s currently the same for every resume; add per-role-type variants if you want │
│ │ it tailored │
├────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Which bullets appear / │ skills/materials/tailor/SKILL.md — add framing guidance for specific role types │
│ ordering │ │
├────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ The cover letter │ The template doesn’t have a cover letter page yet — that needs to be built │
├────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Formatting / layout │ references/TEMPLATE_DanielWarfield_Resume_cover.docx — edit the base template │
└────────────────────────────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
What are you seeing that you want to change?In an unstructured “LLM Wiki” approach, figuring out what information to change in a large harness can be challenging. Because the agent harnesses standard imposes a referencing structure, we can leverage that structure to make modifications.
Let’s take a moment to discuss this harness and its implications from a high level. Then I’ll show you how to initialize your own harness for Claude, and then we can conclude.
A Discussion of Implications
The harness above is doing work that requires both constraint and open-endedness. It requires context, tools, and consistency over numerous sessions. The agent harnesses standard, paired with the metaskill, allows claude to leverage that structure consistently and repeatedly.
One of the great things about a harness is that it’s project-configurable. In Claude, plugins (which are the closest similar construct) can only be installed at a global level, which makes it hard to isolate different skills and contexts to different roles.
If you’re a content creator, for instance, you might want to want to consider creating tiktok videos, vs drafting video scripts, vs creating blog posts as different roles with very different rules. However, if you need to install all of these as a high-level plugin that’s always exposed, claude might choose to use the wrong plugin at the wrong time. Thus, it can be difficult to reign claude into the functionality you want to satisfy a specific role.
Because harnesses are a directory, you can cd into that directory, run claude, and then tell it to load the harness. Because HARNESS.md is a relative entry point, it’s easy to ensure that claude is obeying the proper context and using the correct reference material. Thus you can have many, many harnesses on a single machine, all specifying different roles, with little risk of cross-contamination.
One thing you might be thinking is that this is a fairly simple demo, and it is. It’s more complex than you’d think, iterating on a harness to output good quality content consistently is challenging, and the structure of agent harnesses makes that feasible, but job application isn’t exactly rocket surgery. I’m excited to discuss configurable leaves later, which allows for abstraction around information in a harness that I think will enable very sophisticated use cases. You can expect a follow-up article that goes into that in depth.
Another thought you might be considering is how harnesses are structured within a larger agentic system. Can an agent use more than one harness? Can harnesses be nested in some way? To be honest, I’m still thinking about what these questions mean practically, but I’m excited to begin working on agentic clients that leverage the agent harnesses standard with the hopes of understanding these questions more thoroughly. The agent harnesses standard makes no constraints around how harnesses interact with each other intentionally, so that developers can leverage them in ways that suit their needs. Stay tuned for follow up articles that explore that as well.
Anywho, agent harnesses is still a work in progress, and there will be follow ups describing that progress. Let’s wrap this up by exploring how you can create a harness yourself.
Creating a Harness
There are two pip-installable repos I’m maintaining that can aid you in creating harnesses that follow the agent harnesses standard. These are both early constructs that will continue to mature over the coming months.
agentharnesses-cli exposes a variety of command line tools around creating and evaluating harnesses
And harnesses-ref is a specific Python library that allows a user to evaluate if a harness obeys the agent harnesses standard.
The agentharnesses-cli uses harnesses-ref under the hood as a dependency, and exposes all of its functionality, so we can go ahead and simply install the agent harnesses CLI.
pip install agentharnesses-cli
that will be exposed as a command line tool called ahar (short for Agent Harnesses). we can call ahar init to create a new harness. That will ask us if we want to create a bare harness, or one pre-loaded with tools to be made easily compatible with Claude.
danielwarfield@mac test % ahar init
Initialized harness ‘test’ in /Users/danielwarfield/Desktop/test
HARNESS.md
README.md
.gitignore
.claude/settings.json
skills/SKILLS.md
references/REFERENCES.md
Claude Code preset:
claude Full Claude Code setup: metaskill plugin + maintain-harness skill
empty Bare minimum: no additional plugins or skills
Preset [claude]: I’ll just use the default, and boom, we have a harness. I can run ahar validate . to check if the harness obeys the agent harness standard, which obviously it does.
danielwarfield@mac test % ahar validate .
✓ . is validand we can run ahar show . to print out all the key files in our harness.
danielwarfield@mac test % ahar show
/
├── HARNESS.md [root]
├── references/
│ └── REFERENCES.md [routing]
└── skills/
├── SKILLS.md [routing]
└── maintenance/
├── SKILLS.md [routing]
└── modify-harness/
└── SKILL.md [leaf]We can run claude , type in load, and Claude will know exactly what’s up in a few seconds.
danielwarfield@mac test % claude
╭─── Claude Code v2.1.193 ─────────────────────────────────────────────────────────────────────────────╮
│ │ Tips for getting started │
│ Welcome back Daniel! │ Run /init to create a CLAUDE.md file with instructi… │
│ │ ──────────────────────────────────────────────────── │
│ ▐▛███▜▌ │ What’s new │
│ ▝▜█████▛▘ │ Added `autoMode.classifyAllShell` setting to route … │
│ ▘▘ ▝▝ │ Added auto-mode denial reasons to the transcript, t… │
│ │ Added `claude_code.assistant_response` OpenTelemetr… │
│ Sonnet 4.6 · Claude Pro · Daniel Warfield │ /release-notes for more │
│ ~/Desktop/test │ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────╯
❯ load
Read 1 file (ctrl+o to expand)
⏺ This is a stub HARNESS.md that hasn’t been configured yet. Let me check what else is in the project
directory.
Searched for 1 pattern (ctrl+o to expand)
⏺ Skill(agent-harnesses)
⎿ Successfully loaded skill
⏺ Let me summarize the harness to get a full picture of what’s here.
⏺ Bash(python /Users/danielwarfield/Desktop/test/.claude/skills/agent-harnesses/scripts/summarize.py
/Users/danielwarfield/Desktop/test)
⎿ Waiting…
────────────────────────────────────────────────────────────────────────────────────────────────────────
Bash command
python /Users/danielwarfield/Desktop/test/.claude/skills/agent-harnesses/scripts/summarize.py
⏺ Bash(python /Users/danielwarfield/Desktop/test/.claude/skills/agent-harnesses/scripts/summarize.py
/Users/danielwarfield/Desktop/test)
⎿ test/
├── [harness] HARNESS.md — TODO describe what this harness does and the role it give...
│
… +31 lines (ctrl+o to expand)
⏺ This is a freshly scaffolded harness — all the stubs are in place but nothing has been filled in yet.
Here’s what exists:
- HARNESS.md — root entry point (stub, needs description)
- README.md — stub
- references/REFERENCES.md — empty reference index
- skills/SKILLS.md — empty skill index
- skills/maintenance/ — one real skill already present: modify-harness, which helps keep routing files
in sync when you add/move/rename things
The only functional content is the modify-harness skill. Everything else is TODO placeholders.
What would you like to do with this harness? For example:
- Describe its purpose and fill in the stubs
- Add skills or references to it
- Start building it out for a specific use case
✻ Baked for 19sNow we can do pretty much anything we want. I told Claude to make this harness represent all of the articles on IAEE.substack.com, organized by topic, with summaries and key ideas.
After Claude did its thing for a while, scraping my content online and sticking it in the harness, I quit out of claude and then ran ahar validate .
danielwarfield@mac test % ahar validate .
⚠ references/agentic-ai.md: markdown file should have a ‘description’ in frontmatter
⚠ references/data-and-tools.md: markdown file should have a ‘description’ in frontmatter
⚠ references/retrieval-and-rag.md: markdown file should have a ‘description’ in frontmatter
⚠ references/software-engineering.md: markdown file should have a ‘description’ in frontmatter
⚠ references/training-and-fine-tuning.md: markdown file should have a ‘description’ in frontmatter
✓ . is valid
The agent harnesses standard recommends having descriptions in all markdown files so that they can be peeked at via progressive disclosure, but it’s not a strong requirement. It also makes sense that they might not be relevent in this context. Seems like claude made a harness that obeys the standard.
we can run ahar show . to see what structure it came up with.
danielwarfield@mac test % ahar show .
/
├── HARNESS.md [root]
├── references/
│ └── REFERENCES.md [routing]
└── skills/
├── SKILLS.md [routing]
└── maintenance/
├── SKILLS.md [routing]
└── modify-harness/
└── SKILL.md [leafIt actually didn’t change the overall structure of the harness at all, just its contents.
If we use the flag -v allows us to view the tree with varying degrees of verbosity. it defaults to 0, the lowest verbosity, but we can take a peek at descriptions throughout the harness by calling ahar show -v 1
danielwarfield@mac test % ahar show -v 1
/
├── HARNESS.md [root] — Reference harness for all articles published on Intuitively and Exhaustively Explained (IAEE) by Daniel Warfield. Use this to find articles by topic when answering questions about ML, AI, data engineering, hardware, or software practice.
├── references/
│ └── REFERENCES.md [routing] — Index of all IAEE article reference files, organized by topic. Each file lists the articles in that topic with their URLs and descriptions.
└── skills/
├── SKILLS.md [routing] — Index of skill buckets in this harness. Currently contains only maintenance skills for keeping the harness structure up to date.
└── maintenance/
├── SKILLS.md [routing] — Harness upkeep skills — for modifying the harness structure, adding skills and references.
└── modify-harness/
└── SKILL.md [leaf] — Update harness structure files — HARNESS.md, SKILLS.md indexes, REFERENCES.md — to keep routing and descriptions accurate as the harness evolves.And a picture speaks a thousand words; the content seems pretty good.
If we hop back into a new session of claude and tell it to load harness, we’ll see that it understands the new structure quickly.
danielwarfield@mac test % claude
╭─── Claude Code v2.1.193 ─────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ │ Tips for getting started │
│ Welcome back Daniel! │ Run /init to create a CLAUDE.md file with instructions for Claude │
│ │ ──────────────────────────────────────────────────────────────────────────────────── │
│ ▐▛███▜▌ │ What’s new │
│ ▝▜█████▛▘ │ Added `autoMode.classifyAllShell` setting to route all Bash/PowerShell commands thr… │
│ ▘▘ ▝▝ │ Added auto-mode denial reasons to the transcript, the denial toast, and `/permissio… │
│ │ Added `claude_code.assistant_response` OpenTelemetry log event containing the model… │
│ Sonnet 4.6 · Claude Pro · Daniel Warfield │ /release-notes for more │
│ ~/Desktop/test │ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
❯ load harness
⏺ Skill(agent-harnesses)
⎿ Successfully loaded skill
⏺ I’ll start by summarizing the harness structure to understand what’s available.
⏺ Bash(python /Users/danielwarfield/Desktop/test/.claude/skills/agent-harnesses/scripts/summarize.py /Users/danielwarfield/Desktop/test)
⎿ test/
├── [harness] HARNESS.md — Reference harness for all articles published on Intuitive...
│
… +83 lines (ctrl+o to expand)
⏺ The harness is loaded. Here’s what it contains:
IAEE Article Reference Harness — A reference harness for Daniel Warfield’s Intuitively and Exhaustively Explained Substack, covering
73 articles across 13 topic areas:
References (topic indexes):
- ai-fundamentals.md — Neural networks, training dynamics, core ML concepts
- agentic-ai.md — AI agents, LangGraph, MCP, A2A, agent harnesses
- attention-by-hand.md — Step-by-step math walkthroughs of attention/transformers
- computer-vision.md — CNNs, YOLO, CLIP, Flamingo, VQA
- data-and-tools.md — SQL, Python packaging, combinatorics, signal analysis
- graph-ml.md — Graph theory, GCNs, applied graph ML
- hardware-and-infrastructure.md — GPUs, Groq, Spark, Kubernetes
- large-language-models.md — Transformer architecture, GPT/BERT/DeepSeek, positional encoding
- retrieval-and-rag.md — RAG, CRAG, multimodal RAG, cache-augmented generation
- software-engineering.md — Agile, MLOps, experiment tracking
- training-and-fine-tuning.md — LoRA, self-supervised learning, evolutionary optimization
- video-and-generative-models.md — Sora, VAE/beta-VAE
- opinion-and-commentary.md — Essays on AI ethics, industry trends
Skills:
- modify-harness — For updating the harness structure (HARNESS.md, SKILLS.md, REFERENCES.md)
✻ Brewed for 14sand it can leverage that understanding to answer questions quickly and efficiently
❯ what’s the topic with the most articles?
⏺ Let me read all the reference files in parallel to count articles per topic.
Read 13 files (ctrl+o to expand)
⏺ Agentic AI is the topic with the most articles at 10:
┌───────────────────────────┬──────────┐
│ Topic │ Articles │
├───────────────────────────┼──────────┤
│ Agentic AI │ 10 │
├───────────────────────────┼──────────┤
│ Large Language Models │ 6 │
├───────────────────────────┼──────────┤
│ Computer Vision │ 7 │
├───────────────────────────┼──────────┤
│ Hardware & Infrastructure │ 6 │
├───────────────────────────┼──────────┤
│ Retrieval & RAG │ 6 │
├───────────────────────────┼──────────┤
│ AI Fundamentals │ 6 │
├───────────────────────────┼──────────┤
│ Opinion & Commentary │ 6 │
├───────────────────────────┼──────────┤
│ Graph ML │ 4 │
├───────────────────────────┼──────────┤
│ Training & Fine-Tuning │ 4 │
├───────────────────────────┼──────────┤
│ Data & Tools │ 5 │
├───────────────────────────┼──────────┤
│ Software Engineering │ 4 │
├───────────────────────────┼──────────┤
│ Attention (By Hand) │ 5 │
├───────────────────────────┼──────────┤
│ Video & Generative Models │ 3 │
└───────────────────────────┴──────────┘
✻ Sautéed for 17sThere’s a lot more I want to talk about, but I need to work a bit more on agent harnesses before I’m ready to peel back another layer of the onion. I think it’s time to wrap it up.
Conclusion
In this article we started by discussing what a harness is. While divisive, we settled on a working definition based on common language and the needs of modern agentic design
A harness is information and tools that allow a general purpose agentic system to do specific, complex tasks in a repeatable and maintainable manner.
Practically, that ends up being a directory of resources.
The “Agent Harnesses” spec exists to create a lightweight but robust structure around that directory, allowing an agent to leverage this directory of information effectively, while minimizing some of the pitfalls of similar and less structured approaches.
Once we had a working idea of agent harnesses, we explored an example harness and then made our own.
Agent Harnesses is still in early and active development. The concrete is not yet dry on the ideas I outlined in this article. I hope to hear some more constructive feedback and criticism so that the Agent Harnesses spec can further evolve. That said, I do hope that it’s starting to take the shape of something useful. Feel free to check out the website, github repo, and download the CLI so you can use agent harnesses in your projects.
Also, GitHub stars are cool, and people who want to help maintain the standard in these early phases are even cooler. Hope to see you on GitHub.