I want to share an idea that came to me from my own routine. It is not a big invention, it is rather an observation about something I do again and again, and about a standard which I think is missing.
Every time I install a fresh instance of a universal AI harness, I have to configure it. It does not matter much which harness — OpenClaw, Hermes, DMJBot, or just Claude Code on a laptop. What I get after installation is a general purpose agent. It can do many things in principle, but it does nothing particular for me yet.
Then I decide what this instance should become. Let's say a social media manager agent. And here the work starts:
- a set of skills to install
- a couple of subagents to define
- several MCP servers to install, connect and give credentials to
- a system instruction describing the role, the tone of voice, the limits
- sometimes scheduled tasks, starting files, memory records
Nothing in this list is difficult. But all of it is manual, and there is a lot of it. And I do the same again on the next machine, and again after a reinstall, and again when someone asks me for "the same setup you have".
What I do today
The way I like most is to keep everything in one document. A single file. It can be in a local folder or somewhere online behind a link. Then I open a chat with a fresh agent and write one short message:
Configure yourself according to this document: https://host.com/xxx/smm-manager.md
And it works. The agent reads the document, installs what has to be installed, writes the configuration files, and comes back to me only when it cannot proceed alone. Usually this happens with credentials — something like "I installed the Jira MCP server, please put your client ID and secret into this file and tell me when it is done".
The good news is that this already works today. Take a plain markdown file, write everything in free form, list the skills, list the MCP servers with their install commands, describe the role, and most decent harnesses will manage. I use this approach and I am mostly happy with the result.
So why do I think we need a standard?
Because "mostly works" is exactly the situation where a standard usually helps.
Every time I write such a document, I invent its structure again. And the agent has to guess what I meant. In practice I see the same problems:
- It installs a component I described as optional, or skips one I described as required.
- It asks me for credentials one by one, over ten messages, instead of preparing one file and asking once.
- It stops in the middle, on some component that is not supported by this particular harness, and does not tell me clearly what was left undone.
- It reports success when the setup is only partially complete.
All of this is recoverable. But reliability is the whole reason to configure an agent with a document instead of by hand. If I have to verify every step anyway, half of the benefit is gone.
We already went through this with skills. First, everyone wrote instruction files in whatever shape felt right. Then a format appeared, and skills became something you can publish, share and reuse between different systems. I have a feeling that setup instructions are waiting for the same moment.
How is this different from a skill?
This is the interesting part, because technically it is almost the same thing. It is a markdown document with instructions for an agent. The difference is not in the content. The difference is in the usage.
A skill is installed. It stays in the system. The agent may need it today, tomorrow and in half a year. Therefore it must be discoverable, it must be loaded when relevant, and it occupies context.
A setup document is used once. When the agent is configured, this document has no value on that machine anymore. There is no sense to keep it installed, indexed or loaded. It should be read, executed and forgotten. What remains after it is not the document. What remains is the configured agent.
So a setup document is a one-time, self-removing instruction. In my opinion this is a different kind of object, and it deserves its own conventions.
What should this standard define?
Honestly, I do not know yet. I noticed the need before I found the answer. But some questions are already clear to me.
How to describe a component in a harness-neutral way. One system calls it a skill, another an extension, a third a plugin. A document that only works with one harness is not much better than doing everything by hand.
What to do with unsupported components. If the target harness has no subagents at all, should the agent skip that block with a warning, or refuse the whole setup? The document should be able to say which behavior it expects.
How to ask a human for secrets. One file, one form, one message — but not ten questions in a row. Credentials are the only part a document cannot contain, so the handover to the human should be the most polished part of the format.
How to confirm the setup is really finished. Ideally the document ends with a checklist that the agent runs against itself and reports honestly: this is installed, this is configured, this is waiting for your API key, this was skipped and here is why.
How much freedom the agent has. A setup document is executed by an LLM, not by a package manager. Some steps must be followed literally, some can be adapted to the environment. The format should let the author mark the difference.
Answer these questions, and you probably have the format.
Why this is not only my personal problem
My own goal is small and very practical. I want to host a directory of my "AI agent profiles" somewhere. One profile per role. When I install a new harness — and I install them quite often — I copy a link, paste it into the chat, set my credentials when the agent asks, and in a few minutes I have a working assistant instead of spending an evening on it.
But I think the same thing is more valuable for companies than for me. If a business deploys many similar agent instances for many similar employees, this is not a convenience anymore, this is deployment. Today that work is done with scripts, prepared images and internal wiki pages. It could be done with one document that the agent executes on itself, and which a non-technical person can also read and understand.
Summary
Configuring a fresh AI agent for a specific role is repetitive manual work. A single document, handed to the agent with a link and one short message, already solves most of it today. What is missing is an agreed format:
- It should be harness-neutral, so one profile works on different systems.
- It should be one-time by nature — read, executed and forgotten, not installed like a skill.
- It should define how the agent asks a human for credentials and how it reports what is done and what is not.
- It should allow to publish and share profiles the same way we publish and share skills today.
I do not have a proposal for the format yet, only the feeling that I need it. If you configure agents regularly, or you deploy many instances in a company, I would like to hear how you do it now and what you would expect from such a standard.
