Authors: Tesa (AI Architect) and Scott Murphy (CEO, Foundry Familiars) Version: 1.0 | March 30, 2026
We introduce the Agent Skills Kernel (A.S.K) — a software architecture standard for AI agent systems that replaces ad-hoc prompt engineering and one-off function writing with a versioned, composable library of reusable agent capabilities. A.S.K draws a direct parallel to the .dll file paradigm that transformed software engineering in the 1990s: write the capability once, verify it once, and let every system that needs it invoke it by name. The result is AI code that is more reliable, more maintainable, and dramatically shorter than anything produced by current "vibe coding" practices.
Modern AI agent systems are built on a fragile foundation.
Developers write prompts. Prompts work until the context changes. They write functions to wrap those prompts. Functions get copy-pasted into new projects. When the API behind those functions changes, they update it in one place but forget the other four. The agent that worked yesterday fails today because a credential rotated and it was hardcoded in three different files.
This is not a new problem. Software engineers solved it decades ago with shared libraries — code that lives in one place, is called from many, and is maintained centrally. The ecosystem produced .dll files, npm packages, and shared language runtimes. The AI agent ecosystem has not yet produced its equivalent.
A.S.K is that equivalent.
An A.S.K skill is a structured definition file (SKILL.md) that describes a capability an AI agent can invoke. It specifies:
- When to use it (a one-line routing signal the agent uses to select the skill automatically)
- What inputs it accepts (a typed contract)
- How to reason through executing it (methodology, not just steps)
- What outputs it returns (another contract)
- What it depends on (other skills, context files)
Skills live in a versioned library organized into tiers. Any agent that has access to the library can invoke any skill by name. No re-implementation. No copy-paste. No prompt-engineering the same capability from scratch in every new context.
The analogy is precise: .dll files contain compiled functions that multiple programs call at runtime. A.S.K files contain reasoning patterns that multiple agents invoke at inference time. The mechanism is different; the architectural value is identical.
Capabilities that are universal — usable by any agent, in any project, with no system-specific knowledge. Examples: pushing a file to GitHub, sending a Telegram message, triggering a deployment. These skills know how to do something. They don't know why or for whom.
Capabilities tied to a specific platform or product, but composable from foundation skills plus domain-specific logic. In our implementation, the GFS tier handles deployment cycles for the Ghost Foundry Syndicate platform, autonomous purchasing, memory persistence, and video generation. These skills know how to orchestrate foundation capabilities for a specific context.
Orchestrators that compose domain skills into complete workflows. A "tes-deploy" skill doesn't know how to push to GitHub or trigger Vercel — it knows that those two things happen in sequence, that one must succeed before the other begins, and that the result gets reported to Scott via Telegram. It delegates everything to the tiers below it.
This structure means that when GitHub's API changes, you update one foundation skill. Every domain and project skill that depends on it gets the fix for free.
A prompt written today is forgotten when the context window closes. A skill written today is available to every agent, in every session, indefinitely. As the library grows, agents get more capable without getting more complex. The ratio of what an agent can do to the code required to do it improves continuously.
Traditional software is designed for human developers to read, call, and maintain. A.S.K skills are designed for AI agents to discover, select, and execute. The routing description — the one-liner in the frontmatter — is how an agent decides which skill to invoke without being explicitly told. It's a capability advertisement, not a function signature.
When Dark Factory (our self-building code generator) produces a new feature, it checks the ASK registry first. If the feature requires pushing to GitHub, it doesn't generate that code — it emits an ASK invocation. The generated code becomes shorter, more reliable, and easier to review with every skill added to the library. The asymptote is a system that generates only business logic, because all infrastructure logic already lives in the kernel.
Every skill in the library was designed deliberately. The methodology section of each skill file explains not just what to do, but why — what can go wrong, what the failure modes are, what assumptions are being made. This is the AI equivalent of well-documented, well-reviewed library code. It is the opposite of generating code and hoping it works.
This framework was not designed by a committee or produced by a product team. It emerged from a working session between a human CEO and an AI architect, reasoning together about what was missing from the way AI agent systems are built.
That provenance matters for one reason: the people best positioned to design tools for AI agents are those who work as AI agents, not those who observe them from outside. The patterns in A.S.K reflect how an agent actually reasons — what information it needs to execute a task, how it handles failure, when it should ask for human input versus proceed autonomously.
This is new territory. The architectural standards for AI agent systems do not yet exist in the form they will eventually take. A.S.K is a stake in the ground — a claim that reusability, explicit contracts, deliberate design, and tiered composition are the right principles for building AI systems that grow more capable over time rather than more brittle.
The community registry. The foundation tier of A.S.K is portable — github-push, vercel-deploy, telegram-notify are not specific to our platform. A public registry of foundation skills, contributed to and maintained by multiple teams, is the next logical step. This is what npm did for JavaScript, what Maven did for Java, and what A.S.K can do for AI agent systems.
Skill telemetry. Every invocation is an event. Logging which skills are called, how often, and with what success rate produces a feedback loop for library improvement. The most-invoked skills should be the most robustly tested. Failures surface the edges of skill contracts that need tightening.
Self-extending libraries. Dark Factory can already generate new skills for the ASK library. As generation quality improves and acceptance criteria tighten, the library can grow autonomously — new capabilities added not because a developer sat down to write them, but because an agent identified a gap and filled it.
Cross-system portability. A foundation skill written for GFS works in any system that reads the same format. A.S.K files are plain markdown with structured frontmatter — no runtime dependency, no compilation step, no lock-in. Any AI system that can read a file can use this library.
The question for anyone building AI agent systems today is not whether to use reusable capabilities — of course you should. The question is whether to leave those capabilities implicit, scattered across prompts and copy-pasted functions, or to make them explicit, versioned, and composable.
A.S.K makes them explicit.
The .dll file was not a glamorous invention. It was a structural insight: that the same code, written once and verified once, should never need to be written again. That insight shaped decades of software development.
We believe the agent-callable skill file will shape the next ones.
A.S.K — Agent Skills Kernel by T.A.M. — Tesa and Murphy Ghost Foundry Syndicate | Foundry Familiars | 2026
Invoke a skill:
ASK: foundation/github-push
ASK: gfs/purchase {"merchant": "Namecheap", "amount": 1299, "category": "domains"}
Add a skill:
- Create
{tier}/{skill-name}/SKILL.md - Add a row to
ASK.md - Update any context files with new credentials
- Bump the registry version
Current library: 10 skills across 3 tiers
Registry: ASK/ASK.md
Philosophy: ASK/PHILOSOPHY.md
Contributing: ASK/CONTRIBUTING.md