{
  "source_file": "0930",
  "source_platform": "Ghost",
  "author": "Peng Qian / Data Leads Future",
  "title_listed": "How to Use Agent Skills in Enterprise LLM Agent Systems",
  "keywords": "",
  "domain": "大模型算法",
  "content_type": "工程实践",
  "is_paid_flag": "否",
  "url": "https://www.dataleadsfuture.com/how-to-use-agent-skills-in-enterprise-llm-agent-systems/",
  "publish_date": "2026-03",
  "corpus_stage": "",
  "notes": "",
  "id": "7b21f3109d0d",
  "collected_at": "2026-10-02T12:26:52",
  "title": "How to Use Agent Skills in Enterprise LLM Agent Systems",
  "body_markdown": "Agentic AI\nHow to Use Agent Skills in Enterprise LLM Agent Systems\nA thorough and detailed hands-on guide\nPeng Qian\n17 Mar 2026\n—\n12 min read\nShare\nHow To Use Agent Skills In Enterprise LLM Agent Systems. Image by DALL-E-3\nIntroduction\nEnterprise-grade agentic systems have fallen way behind the desktop agent apps that everyone's been buzzing about lately.\nAfter spending the better part of a year building enterprise agent applications, I came to one conclusion:\nif your agent system can't plug into your company's existing business processes, it won't bring real value to your organization.\nDesktop systems like OpenClaw and Claude Cowork solved this problem. They don't change their agent setup at all. Instead, they use Agent Skills to capture human business processes, then share those skills between desktop agent systems through the file system. That's how they tackle one business problem after another.\nBut enterprise users write their skills through a web interface and save them to a database. There's a good chance the process involves complex approval and security audit steps, too. So how does your agent load these skills in real time without any downtime?\nThe latest version of Microsoft Agent Framework finally makes this possible with its Agent Skills feature.\nTL;DR\nWith Agent Skills in Microsoft Agent Framework, enterprise agent systems can load user-defined business process skills from a database in real time, and run the scripts and generated code that come with those skills safely inside containers.\nYour agent system stays secure and stable, while gaining the same flexible business process orchestration that desktop agents enjoy.\nAll the source code in this tutorial is available at the end of the article.\nBefore We Start\nInstall the latest Microsoft Agent Framework\nTo use Agent Skills, install the latest version of Microsoft Agent Framework:\npip install agent-framework --pre\nOr, like me, you can pin the version of\nagent-framework\nin your\npyproject.toml\n:\ndependencies = [\n    \"agent-framework>=1.0.0rc4\",\n    \"agent-framework-ag-ui>=1.0.0b260311\",\n]\nThen tell\nuv\nto allow prerelease versions:\nuv sync --prerelease=allow\nInstall Tavily Agent Skills\nMy end goal is to show you how to share and load Agent Skills between agents deployed across distributed nodes. But I think we should start simple. First, let me show you how to load and use skills from the community.\nLet's start with Tavily Agent Skills. We'll only load the\ntavily-best-practices\nskill. It guides my agent on how to generate Tavily-based search code based on the task at hand, instead of calling a hardcoded function:\nnpx skills add tavily-ai/skills\nDon't worry. After the initial demo, I'll walk you through how to load skills from a database in real time.\nHow to Load Agent Skills from Disk\nLet's start with the most basic approach.\nIn Microsoft Agent Framework, context operations are handled by a base class called\nContextProvider\n. The latest version of MAF ships a\nSkillsProvider\nclass. Use it directly and pass the location of your skills through the\nskill_paths\nattribute, and you're done.\nskill_paths\ndoesn't require a default directory like\n.claude/skills\n, and you can pass in multiple paths.\nskills_provider = SkillsProvider(\n    skill_paths=get_current_directory() / \".agents/skills\",\n)\nNext, create your agent and pass the\nskills_provider\ninstance through\ncontext_providers\n.\nskills_agent = chat_client.as_agent(\n    name=\"SkillsAssistant\",\n    instructions=\"You're a helpful assistant, and you'll respond to user requests according to your skills.\",\n    context_providers=[skills_provider],\n    tools=[code_tool],\n)\nTo run the Python code the agent writes based on the Tavily skill instructions, you need to pass a\ncode_interpreter\ntool to the agent. Let the code run inside a container environment. I'll cover that in detail later.\nWrite a\nmain\nmethod to test the agent:\nasync def main():\n    async with code_executor:\n        session = agent.create_session()\n        result = await skills_agent.run(\n            \"Check how gold ETFs performed in February 2026 and give some investment advice.\",\n            session=session\n        )\n        \n        print(result)\nMicrosoft Agent Framework provides an OpenTelemetry-based telemetry tool. I hooked it up to MLflow. Let's run the agent once and see what happens:\nThrough MLflow, you can see that the agent successfully loaded and executed the Agent Skills. Image by Author\nYou can see that once the agent decided it needed Tavily to search, it loaded the full\nSKILL.md\ndocument, wrote Tavily search code following the instructions, then sent it to the code interpreter for execution. Exactly what we expected.\nYou can learn how to use MLFlow in this article:\nMonitoring Qwen 3 Agents with MLflow 3.x: End-to-End Tracing Tutorial\nEnhance your multi-agent application’s observability, explainability and Traceability\nData Leads Future\nPeng Qian\nHow Agent Skills Work\nNow let's talk about how to get the most out of Agent Skills in enterprise systems. That means loading external skills in real time, containerizing the code interpreter, and managing context more carefully.\nBut before we go there, let's dig into how Agent Skills actually work inside MAF, so the rest of this tutorial makes more sense.\nAs I mentioned,\nSkillsProvider\nextends\nBaseContextProvider\n, which means it works by operating on the agent's context.\nWhen you initialize\nSkillsProvider\n, you pass one or more search paths to the\nskill_paths\nattribute. Take the\n.agents/skills\ndirectory as an example. On startup,\nSkillsProvider\nrecursively searches this directory and finds every subdirectory that contains a\nSKILL.md\nfile. Then it extracts the\nname\nand\ndescription\nfields from each\nSKILL.md\nfile, along with the file content, and stores everything in a\nSkill\nobject.\nSkillsProvider\nloops through these\nSkill\nobjects, formats the\nname\nand\ndescription\nfields like this, and merges them into the agent's system prompt. This keeps the agent aware of available skills without loading their full content upfront.\nlines.append(\"  <skill>\")\nlines.append(f\"    <name>{xml_escape(skill.name)}</name>\")\nlines.append(f\"    <description>{xml_escape(skill.description)}</description>\")\nlines.append(\"  </skill>\")\nSkillsProvider\nalso adds two methods to the agent through context:\nload_skill\nand\nread_skill_resource\n. When the agent decides which skill it needs based on the user's request, it calls\nload_skill\nto look up the matching\nSkill\nobject by name and loads its full content into the context.\nIf a skill's content references extra resource files like\nreferences/search.md\n, the agent can call\nread_skill_resource\nto load those files.\nHere's the full workflow:\nA diagram illustrating the workflow of SkillsProvider. Image by Author\nThis design follows the progressive disclosure principle defined by\nagentskills.io\n. Skill content loads into the agent's context gradually, only when needed. No context explosion, no wasted tokens.\nAgent Skills for Enterprise Systems\nAlright, enough theory. Let's get into today's main topic:\nhow to use Agent Skills in enterprise-grade agentic systems\n.\nLoad skills from external systems in real time\nWhat if business users write their skills through a cloud-based web page and save them to a database? How do you handle that?\nWe need a new approach to sync and apply Agent Skills in real time.\nAs I covered earlier, when\nSkillsProvider\ninitializes, it loads all\nSKILL.md\nfiles from the input paths into an in-memory list of\nSkill\nobjects.\nBesides the file system approach,\nSkillsProvider\nalso supports Code Defined Skills, where you write skill content directly in code:\nfrom pathlib import Path\nfrom agent_framework import Skill, SkillsProvider\n\nmy_skill = Skill(\n    name=\"my-code-skill\",\n    description=\"A code-defined skill\",\n    content=\"Instructions for the skill.\",\n)\nThen pass it to\nSkillsProvider\nthrough the\nskills\nattribute:\nskills_provider = SkillsProvider(\n    skill_paths=Path(__file__).parent / \"skills\",\n    skills=[my_skill],\n)\nThis opens the door to managing and loading skills from a database. But the original\nSkillsProvider\nclass only accepts skills at initialization time. We want to load skills dynamically while the agent system is running, so we need to extend\nSkillsProvider\n.\nAfter reading the source code, I found that every class extending\nBaseContextProvider\nhas a\nbefore_run\nmethod that gets called when the agent calls\nrun\n. We can load the latest skills from the database before\nbefore_run\nexecutes, then update\nSkillsProvider\n's\nself._skills\nlist and refresh the skills description in\ninstructions\n.\nWhat I need is a hook method. Every time before\nbefore_run\nruns, this hook fetches the latest skills. All I need to do is put the database fetching logic inside this hook.\nThe workflow for loading skills from the database in real time. Image by Author\nThe simplest way to give\nSkillsProvider\nthis hook is to build an\nUpdatableSkillsProvider\nsubclass. This subclass accepts a\nskills_updater\nparameter at initialization:\nclass UpdatableSkillsProvider(SkillsProvider):\n    def __init__(\n        self,\n        skill_paths: str | Path | Sequence[str | Path] | None = None,\n        *,\n        skills_updater: Callable[[], Awaitable[Sequence[Skill]]] | None = None,\n        **kwargs\n    ):\n        super().__init__(\n            skill_paths=skill_paths,\n            **kwargs,\n        )\n        self._skills_updater = skills_updater\n        ...\nUpdatableSkillsProvider\ncalls the hook through a private\n_update\nmethod, which also updates\nself._skills\nand the agent's system prompt. Then\nbefore_run\ncalls\n_update\nto keep skills fresh in real time:\nclass UpdatableSkillsProvider(SkillsProvider):\n    ...\n    async def _update(self) -> None:\n        if self._skills_updater is None:\n            return\n            \n        try:\n            new_skills = await self._skills_updater()\n            \n            for skill in new_skills:\n                self._skills[skill.name] = skill\n                \n            has_scripts = any(s.scripts for s in self._skills.values())\n            \n            self._instructions = _create_instructions(\n                prompt_template=self._instruction_template,\n                skills=self._skills,\n                include_script_runner_instructions=has_scripts,\n            )\n            \n            self._tools = self._create_tools(\n                include_script_runner_tool=has_scripts,\n                require_script_approval=self._require_script_approval,\n            )\n            \n        except Exception as exc:\n            logger.exception(\"Failed to update skills: %s\", exc)\n            \n    @override\n    async def before_run(\n        self,\n        *,\n        **kwargs\n    ) -> None:\n        await self._update()\n        await super().before_run(\n            **kwargs\n        )\nLet's write a\nget_latest_skills\nhook to simulate loading the latest skills from a database:\n@lru_cache\nasync def get_latest_skills() -> list[Skill]:\n    \"\"\"\n    Pseudocode. In this hook method, you can read the skills text from the database \n    and dynamically build Skill objects.\n    :return: \n    \"\"\"\n    code_style_skill = Skill(\n        name=\"code-style\",\n        description=\"Coding style guidelines and conventions for the team\",\n        content=dedent(\"\"\"\\\n            Use this skill when answering questions about coding style,\n            conventions, or best practices for the team.\n        \"\"\"),\n    )\n    \n    return [code_style_skill]\nCall the agent's\nrun\nmethod, then check in MLFlow whether the skills loaded by\nget_latest_skills\nshow up in the agent's system prompt:\nThe skills loaded from the database have been updated into the agent's system prompt. Image by Author\nThe hook method works. We can now load skills from a database in real time.\nRun scripts from skills safely inside containers\nAs of the latest version, Microsoft Agent Framework can't run Python scripts locally or inside containers. But most skills guide the agent through business logic using scripts, so we need to give the agent the ability to run those scripts in a code interpreter.\nAs the predecessor to MAF, Autogen provided a way to run Python scripts inside Docker containers. You can learn about that in this article:\nExclusive Reveal: Code Sandbox Tech Behind Manus and Claude Agent Skills\nUse Jupyter code executor to help your agent finish tasks in a smarter way\nData Leads Future\nPeng Qian\nWe need something like Autogen's\nDockerCommandLineCodeExecutor\nfor Agent Framework. With the help of AI coding tools, building a code executor for Agent Framework isn't hard. (You can find it in the source code repo at the end of the article.)\ncode_executor = DockerCommandLineCodeExecutor(\n    image=\"python-code-sandbox\",\n    work_dir=work_dir,\n    delete_tmp_files=True,\n    environment={\n        \"TAVILY_API_KEY\": os.environ.get(\"TAVILY_API_KEY\"),\n    }\n)\nTo keep LLM calls simple, we also need an object-oriented\nCodeExecutionTool\n:\nclass CodeExecutionTool:\n    \"\"\"Tool for executing code using a CodeExecutor.\"\"\"\n    \n    def __init__(self, executor: CodeExecutor) -> None:\n        self._executor = executor\n    async def execute_code(self, code: str, language: Literal[\"python\", \"sh\"] = \"python\") -> str:\n        result = await self._executor.execute_code_blocks(\n            [CodeBlock(code=code, language=language)],\n            CancellationToken(),\n        )\n        return result.output\nNext, initialize an\nexecute_code\ntool and wire it up to the agent at initialization:\ncode_tool = CodeExecutionTool(code_executor).execute_code\nIn MLflow, you can see that when the agent needs to search the web, it generates Python code based on the skill's instructions and sends it to the container for execution:\nThe agent generated code based on the skill's instructions and executed it in a container. Image by Author\nThis approach not only lets the agent run code defined in skills, but also keeps that execution safe inside a container.\nOf course, in a server-side deployment, you'd send code to a centralized Jupyter kernel environment for execution. But that's a whole other story. You can dig into that in my other articles.\nHow I Crushed Advent of Code And Solved Hard Problems Using Autogen Jupyter Executor and Qwen3\nA detailed guide on using AI to generate code and solve puzzles automatically and quickly\nData Leads Future\nPeng Qian\nReduce context length even further\nAgent Skills uses progressive disclosure to keep irrelevant skill content from eating up your context window. But as the conversation or task moves forward, skill content that was loaded into earlier messages will still pile up in the context over time.\nAgent systems today have several context pruning techniques available. Context trimming and context compression, both common in desktop agents, work really well.\nThe difference between context pruning and context compression. Image by Author\nBeyond those two, today I want to share a context engineering technique I discovered at work that fits Agent Skills even better.\nAs you know, in enterprise scenarios, loading a skill usually means running one atomic workflow: researching a topic through web search? Sure. Running a SWOT analysis on a company and writing a report? No problem.\nThese workflows all share one thing in common. You give the agent the right input, then wait for it to return an output. Which skill the agent loaded, and how it worked through the task — I honestly don't care. I wouldn't even mind if the agent unloaded the skill after finishing to save tokens.\nThat sounds a lot like how a function works. So, can we use an agent with skills loaded as a tool for another agent? Absolutely. That's exactly what I do.\nMicrosoft Agent Framework has a method on Agent called\nas_tool\n. It turns an agent into a function-callable tool.\nSo I designed a main agent. The main agent takes user requests and generates the right response to return. The agent with Agent Skills loading capability turns itself into a tool for the main agent using\nas_tool\n.\nagent = chat_client.as_agent(\n    name=\"Assistant\",\n    instructions=dedent(\"\"\"\n    You're a smart little helper who, for each user request, \n    picks the right task description to call a tool, gets the answer, \n    and then delivers the final result.\n    \"\"\"),\n    tools=[skills_agent.as_tool()],\n)\nThe skills agent's workflow stays the same. It loads the right skill based on the task description, generates and runs code, then returns the result.\nThe skill agent is provided as a tool for the main agent to call. Image by Author\nBut the main agent is different. Its context only holds user messages, the message calling the skills agent tool, and the final response. No skill-related content at all. The main agent's context stays clean, and even after running for a long time, it won't interfere with the LLM.\nKeep the main agent's context clean by loading skills into the sub-agent. Image by Author\nThere's a nice bonus too. LLMs know what they want better than humans do, so before the main agent calls the skills agent, it rewrites the user's task into something more precise. This helps the skills agent execute more accurately.\nConclusion\nThat's everything I have for you today on Agent Skills for enterprise agent systems.\nUnlike desktop agents, enterprise agent systems run on cloud servers. There's no way to update an agent's skills through the file system in real time without downtime.\nSo I went with a targeted approach. This approach lets users write skill content through a web interface and save it to a database, while agents read the latest skills in real time and sync them across server nodes.\nI used the latest version of Microsoft Agent Framework to build this, but you can use any other framework. The principles are the same.\nI also covered how to run scripts the agent generates from skills inside containers, which is much safer than running scripts directly on a desktop system.\nI shared a context management approach I found at work that works especially well for skills-based agents.\nThe Microsoft Agent Framework API is still a bit unstable. If anything is unclear, feel free to leave a comment, and I'll get back to you as soon as I can.\nThanks for subscribing! Share this with your friends if you think it might help someone else.\nFollow Data Leads Future\nOne practical story every month, sharing my hard-learned experiences in the enterprise AI space.\nSubscribe\nEmail sent! Check your inbox to complete your signup.\nNo spam, No ads, you can unsubscribe anytime.\nSource Code\nGet the source code for this article.\nStart using it right away and save yourself a ton of trial and error time.\nGrab the Source Code",
  "metadata": {
    "title": "How to Use Agent Skills in Enterprise LLM Agent Systems",
    "description": "Learn how to use Agent Skills in enterprise LLM agents: load skills from a database in real time, run scripts in containers, and keep context clean.",
    "keywords": null,
    "author": null,
    "og:site_name": "Data Leads Future",
    "og:type": "article",
    "og:title": "How to Use Agent Skills in Enterprise LLM Agent Systems",
    "og:description": "A thorough and detailed hands-on guide",
    "og:url": "https://www.dataleadsfuture.com/how-to-use-agent-skills-in-enterprise-llm-agent-systems/",
    "og:image": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/size/w1200/2026/03/agent_skills.webp",
    "og:image:width": "1200",
    "og:image:height": "686",
    "twitter:card": "summary_large_image",
    "twitter:title": "How to Use Agent Skills in Enterprise LLM Agent Systems",
    "twitter:description": "A thorough and detailed hands-on guide",
    "twitter:url": "https://www.dataleadsfuture.com/how-to-use-agent-skills-in-enterprise-llm-agent-systems/",
    "twitter:image": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/size/w1200/2026/03/agent_skills.webp",
    "twitter:label1": "Written by",
    "twitter:data1": "Peng Qian",
    "twitter:label2": "Filed under",
    "twitter:data2": "Agentic AI, Microsoft Agent Framework, Generative AI",
    "twitter:site": "@qtalen",
    "twitter:creator": "@qtalen",
    "article:published_time": "2026-03-17T10:18:19.000Z",
    "article:modified_time": "2026-08-11T01:52:52.000Z",
    "article:tag": "Generative AI"
  },
  "paywall": {
    "listed_paid": false,
    "detected": false,
    "marker": "",
    "public_only": false,
    "policy": "付费/会员内容只保留页面公开可见部分，不绕过付费墙"
  },
  "crawl": {
    "success": true,
    "status_code": 200,
    "error": ""
  },
  "code_blocks": [
    {
      "file": "attachments/7b21f3109d0d/code/body-000.txt",
      "chars": 33,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-001.txt",
      "chars": 94,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-002.txt",
      "chars": 26,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-003.txt",
      "chars": 31,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-004.txt",
      "chars": 95,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-005.txt",
      "chars": 240,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-006.txt",
      "chars": 293,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-007.txt",
      "chars": 191,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-008.txt",
      "chars": 204,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-009.txt",
      "chars": 108,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-010.txt",
      "chars": 416,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-011.txt",
      "chars": 1177,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-012.txt",
      "chars": 557,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-013.txt",
      "chars": 215,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-014.txt",
      "chars": 459,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-015.txt",
      "chars": 57,
      "language": "text"
    },
    {
      "file": "attachments/7b21f3109d0d/code/body-016.txt",
      "chars": 300,
      "language": "text"
    }
  ],
  "images": [
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/size/w1200/2026/03/agent_skills.webp",
      "bytes": 100234,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/000.webp",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/size/w1200/2026/03/agent_skills.webp",
      "alt": "How To Use Agent Skills In Enterprise LLM Agent Systems.",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image.png",
      "bytes": 37534,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/005.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image.png",
      "alt": "Through MLflow, you can see that the agent successfully loaded and executed the Agent Skills.",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/icon/color_192_192-66.png",
      "bytes": 17721,
      "reused": false,
      "local_path": "attachments/7b21f3109d0d/images/body-3b93cb186f5cb7b1f6b8.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/icon/color_192_192-66.png",
      "alt": "",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/thumbnail/Tracing-with-MLflow-3.x-1-2.webp",
      "bytes": 99038,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/007.webp",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/thumbnail/Tracing-with-MLflow-3.x-1-2.webp",
      "alt": "",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-1.png",
      "bytes": 17480,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/008.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-1.png",
      "alt": "A diagram illustrating the workflow of SkillsProvider.",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-2.png",
      "bytes": 20080,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/010.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-2.png",
      "alt": "The workflow for loading skills from the database in real time.",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-3.png",
      "bytes": 34020,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/012.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-3.png",
      "alt": "The skills loaded from the database have been updated into the agent's system prompt. ",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/icon/color_192_192-67.png",
      "bytes": 17721,
      "reused": false,
      "local_path": "attachments/7b21f3109d0d/images/body-5a62a0e63277bdfdce6c.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/icon/color_192_192-67.png",
      "alt": "",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/thumbnail/cover-14.webp",
      "bytes": 105414,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/014.webp",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/thumbnail/cover-14.webp",
      "alt": "",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-4.png",
      "bytes": 30809,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/015.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-4.png",
      "alt": "",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/icon/color_192_192-68.png",
      "bytes": 17721,
      "reused": false,
      "local_path": "attachments/7b21f3109d0d/images/body-42e399f9144360b9421c.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/icon/color_192_192-68.png",
      "alt": "",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/thumbnail/jupyter_executor_cover-2.webp",
      "bytes": 29218,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/017.webp",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/thumbnail/jupyter_executor_cover-2.webp",
      "alt": "",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-5.png",
      "bytes": 20302,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/018.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-5.png",
      "alt": "The difference between context pruning and context compression.",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-6.png",
      "bytes": 25452,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/020.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-6.png",
      "alt": "The skill agent is provided as a tool for the main agent to call.",
      "downloaded": true
    },
    {
      "status": "ok",
      "url": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-7.png",
      "bytes": 16110,
      "reused": true,
      "local_path": "attachments/7b21f3109d0d/images/022.png",
      "src": "https://storage.ghost.io/c/33/67/33678c00-2c15-4961-93e9-497b427e2006/content/images/2026/03/image-7.png",
      "alt": "Keep the main agent's context clean by loading skills into the sub-agent.",
      "downloaded": true
    }
  ],
  "audio": [],
  "videos": [],
  "links": [
    {
      "href": "https://www.dataleadsfuture.com/tag/agentic-ai/",
      "label": "Agentic AI",
      "type": "a"
    },
    {
      "href": "https://www.dataleadsfuture.com/author/peng/",
      "label": "",
      "type": "a"
    },
    {
      "href": "https://www.dataleadsfuture.com/monitoring-qwen-3-agents-with-mlflow-3-x-end-to-end-tracking-tutorial/",
      "label": "Monitoring Qwen 3 Agents with MLflow 3.x: End-to-End Tracing Tutorial Enhance your multi-agent application’s observabili",
      "type": "a"
    },
    {
      "href": "https://agentskills.io/home",
      "label": "agentskills.io",
      "type": "a"
    },
    {
      "href": "https://www.dataleadsfuture.com/exclusive-reveal-code-sandbox-tech-behind-manus-and-claude-agent-skills/",
      "label": "Exclusive Reveal: Code Sandbox Tech Behind Manus and Claude Agent Skills Use Jupyter code executor to help your agent fi",
      "type": "a"
    },
    {
      "href": "https://www.dataleadsfuture.com/how-i-crushed-advent-of-code-and-solved-hard-problems-using-autogen-jupyter-executor-and-qwen3/",
      "label": "How I Crushed Advent of Code And Solved Hard Problems Using Autogen Jupyter Executor and Qwen3 A detailed guide on using",
      "type": "a"
    }
  ],
  "repair_version": 2,
  "repaired_at": "2026-10-14T10:47:46Z",
  "source_url": "https://www.dataleadsfuture.com/how-to-use-agent-skills-in-enterprise-llm-agent-systems/",
  "papers": [],
  "actual_video_files": [],
  "body_chars": 18647,
  "expected_body_images": 15,
  "discovery_status": "ok",
  "delivery_status": "ok",
  "missing_reason": "",
  "raw_html": "attachments/7b21f3109d0d/pages/source.html",
  "local_html": "attachments/7b21f3109d0d/pages/article.html",
  "body_base_path": "attachments/7b21f3109d0d/pages/",
  "body_markdown_path": "attachments/7b21f3109d0d/pages/article.md"
}