{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-huggingface--agents-course","slug":"huggingface--agents-course","name":"agents-course","type":"repo","url":"https://github.com/huggingface/agents-course","page_url":"https://unfragile.ai/huggingface--agents-course","categories":["ai-agents"],"tags":["agentic-ai","agents","course","huggingface","langchain","llamaindex","smolagents"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-huggingface--agents-course__cap_0","uri":"capability://planning.reasoning.progressive.agent.architecture.curriculum.with.thought.action.observation.cycle.teaching","name":"progressive agent architecture curriculum with thought-action-observation cycle teaching","description":"Teaches the foundational TAO (Thought-Action-Observation) cycle through structured lessons that decompose agent decision-making into discrete steps: LLM reasoning (Thought), tool invocation (Action), and result integration (Observation). The course uses a four-unit progression model that builds from basic LLM concepts to complex multi-framework implementations, with each unit scaffolding knowledge through conceptual explanations, code walkthroughs, and interactive quizzes that validate understanding of agent loop mechanics.","intents":["Understand how LLMs function as reasoning engines within agent architectures","Learn the complete decision-making cycle that agents execute to solve problems","Build mental models of when and how agents invoke external tools","Grasp the feedback mechanisms that allow agents to refine their reasoning"],"best_for":["ML engineers transitioning from traditional NLP to agentic systems","Developers building their first autonomous agents","Teams evaluating agent frameworks for production deployment"],"limitations":["Course material is static and does not adapt to learner pace or background","No built-in sandbox environment for hands-on experimentation during lessons","Multilingual content coverage is incomplete (primarily English with partial Chinese translations)"],"requires":["Basic Python proficiency (3.8+)","Familiarity with transformer models and LLM APIs","Access to LLM providers (OpenAI, Anthropic, or Hugging Face models)"],"input_types":["text (lesson content)","code examples (Python)"],"output_types":["conceptual understanding","quiz validation","code templates"],"categories":["planning-reasoning","education"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_1","uri":"capability://planning.reasoning.multi.framework.agent.implementation.comparison.and.pattern.mapping","name":"multi-framework agent implementation comparison and pattern mapping","description":"Provides side-by-side architectural comparisons of three distinct agent frameworks (smolagents, LlamaIndex, LangGraph) by mapping their core classes, execution models, and use cases to the same underlying agent concepts. Each framework section explains how it implements the TAO cycle differently: smolagents uses code generation, LlamaIndex uses RAG-focused workflows with QueryEngine abstractions, and LangGraph uses explicit StateGraph nodes with conditional routing. The course teaches when to choose each framework based on problem characteristics (general-purpose vs. document-heavy vs. complex state management).","intents":["Evaluate which agent framework best fits a specific use case or architectural constraint","Understand how different frameworks abstract the same agent concepts","Migrate agent code between frameworks by understanding their execution model differences","Design agents that leverage framework-specific strengths (code generation, RAG, state management)"],"best_for":["Architects selecting agent frameworks for production systems","Teams with existing LangChain/LlamaIndex investments evaluating smolagents","Developers building complex agents requiring conditional logic or state persistence"],"limitations":["Comparison is educational rather than performance-benchmarked; no latency or throughput metrics provided","Does not cover framework integration patterns (e.g., using LangGraph with LlamaIndex RAG)","Framework versions taught may lag behind latest releases; requires manual updates"],"requires":["Python 3.9+","Installation of target framework (smolagents, llama-index, langgraph)","Understanding of agent fundamentals from Unit 1"],"input_types":["text (framework documentation)","code examples (Python)"],"output_types":["framework selection criteria","code templates per framework","architecture decision records"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_10","uri":"capability://planning.reasoning.gaia.benchmark.evaluation.framework.for.standardized.agent.assessment","name":"gaia benchmark evaluation framework for standardized agent assessment","description":"Teaches how to use the GAIA (General AI Assistant) benchmark to evaluate agent reasoning quality across diverse tasks. GAIA provides a standardized set of multi-step reasoning tasks with ground truth answers, enabling consistent comparison of agent implementations, frameworks, and model choices. The course covers benchmark task structure (questions requiring multi-step reasoning, tool use, and information synthesis), evaluation metrics (exact match, partial credit), and how to interpret benchmark results to identify agent weaknesses. Includes patterns for running agents against benchmarks, collecting failure cases, and using benchmark results to guide agent improvements.","intents":["Evaluate agent reasoning quality using a standardized, published benchmark","Compare agent implementations, frameworks, and models using consistent metrics","Identify agent weaknesses through failure case analysis on benchmark tasks","Track agent improvement over time using benchmark performance as a metric"],"best_for":["Researchers comparing agent architectures and approaches","Teams evaluating agent frameworks for production deployment","Projects with strict quality requirements requiring standardized evaluation"],"limitations":["GAIA benchmark is fixed; doesn't adapt to domain-specific agent tasks","Benchmark evaluation is expensive (multiple LLM calls per task); costs scale with agent complexity","Benchmark results may not correlate with real-world agent performance in specific domains","Benchmark tasks are primarily text-based; limited coverage of multimodal or specialized agent tasks"],"requires":["Python 3.9+","GAIA benchmark dataset (publicly available)","Agent implementation to evaluate","LLM API access (OpenAI, Anthropic, or local)","Evaluation infrastructure (metrics computation, result tracking)"],"input_types":["GAIA benchmark tasks (questions, ground truth answers)","agent outputs"],"output_types":["benchmark scores (accuracy, partial credit)","failure case analysis","performance comparison across agents"],"categories":["planning-reasoning","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_11","uri":"capability://text.generation.language.interactive.course.platform.with.multilingual.content.and.community.engagement","name":"interactive course platform with multilingual content and community engagement","description":"Provides a structured learning platform built on Hugging Face's infrastructure with progressive units, quizzes, and community features (Discord integration). The course uses a hierarchical table-of-contents system that guides learners through four units plus bonus content, with each unit containing conceptual lessons, code walkthroughs, and knowledge checks. The platform supports multilingual content (English primary, partial Chinese translations), enabling global accessibility. Community features (Discord channel) enable peer learning and instructor support, creating a cohort-based learning experience.","intents":["Access a structured, progressive curriculum for learning agent development","Validate understanding through quizzes and interactive exercises","Engage with instructors and peers through community channels","Access course content in multiple languages"],"best_for":["Individual learners seeking structured agent development education","Teams conducting internal training on agent frameworks","Non-English speakers learning agent development"],"limitations":["Course content is static; does not adapt to learner pace or background","Multilingual coverage is incomplete (primarily English with partial translations)","Community support depends on instructor availability; response times may be slow","No built-in hands-on sandbox; learners must set up local environments"],"requires":["Web browser (modern, JavaScript-enabled)","GitHub account (for accessing course repository)","Discord account (for community engagement)","Local development environment for hands-on exercises"],"input_types":["text (lesson content)","code examples (Python)"],"output_types":["quiz responses","course completion certificates (if applicable)","community discussion threads"],"categories":["text-generation-language","education"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_2","uri":"capability://code.generation.editing.code.first.agent.development.with.smolagents.codeagent.and.toolcallingagent.patterns","name":"code-first agent development with smolagents codeagent and toolcallingagent patterns","description":"Teaches smolagents' dual-agent approach where CodeAgent generates executable Python code as its reasoning output (allowing complex logic, loops, and conditionals) while ToolCallingAgent uses structured JSON schemas for tool invocation. The course explains how smolagents integrates with Hugging Face Hub for model access, how to define custom tools with type hints and docstrings, and how the framework handles code execution sandboxing. Includes patterns for error recovery, tool chaining, and leveraging code generation for multi-step reasoning that would require explicit prompting in other frameworks.","intents":["Build agents that reason through code generation rather than natural language planning","Define reusable tools with automatic schema extraction from Python signatures","Implement complex agent logic (loops, conditionals, variable state) within a single agent step","Integrate Hugging Face models and Hub resources directly into agent workflows"],"best_for":["Python-first teams building agents for data processing and automation","Developers comfortable with code generation and execution sandboxing","Projects leveraging Hugging Face Hub models and datasets"],"limitations":["Code generation approach requires careful prompt engineering to avoid hallucinated imports or unsafe code","Sandboxing adds latency (~100-300ms per agent step) compared to direct tool calling","Limited to Python; cannot generate code in other languages","Tool definitions require Python type hints; less flexible for dynamic or untyped tools"],"requires":["Python 3.9+","smolagents library (pip install smolagents)","Hugging Face API token for model access","Understanding of Python type hints and docstring conventions"],"input_types":["text (agent task description)","Python function definitions (tool definitions)","structured data (tool parameters)"],"output_types":["generated Python code (CodeAgent)","structured JSON tool calls (ToolCallingAgent)","execution results"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_3","uri":"capability://memory.knowledge.rag.integrated.agent.workflows.with.llamaindex.queryengine.and.agentworkflow.abstractions","name":"rag-integrated agent workflows with llamaindex queryengine and agentworkflow abstractions","description":"Teaches LlamaIndex's agent architecture which couples retrieval-augmented generation (RAG) with agent reasoning through QueryEngine abstractions that encapsulate document indexing, retrieval, and synthesis. The course explains how LlamaIndex agents differ from general-purpose agents by optimizing for document-heavy workflows: agents use QueryEngine to retrieve relevant context before reasoning, reducing hallucination and grounding responses in source documents. Includes patterns for multi-document reasoning, hierarchical indexing, and combining multiple QueryEngines (e.g., vector search + keyword search) within a single agent.","intents":["Build agents that reason over large document collections without exceeding context windows","Implement retrieval-augmented agents that cite source documents in their reasoning","Design multi-index agents that combine different retrieval strategies (semantic, keyword, metadata)","Optimize agent performance for knowledge-intensive tasks like customer support and research"],"best_for":["Teams building document-centric agents (customer support, knowledge bases, research tools)","Projects requiring source attribution and explainability in agent reasoning","Applications with large document collections that exceed LLM context windows"],"limitations":["RAG-first design adds retrieval latency (~500ms-2s per agent step) compared to pure reasoning agents","Requires upfront document indexing and embedding computation; not suitable for real-time data","QueryEngine abstraction can obscure retrieval mechanics; harder to debug retrieval failures","Limited support for complex conditional routing compared to LangGraph"],"requires":["Python 3.9+","llama-index library (pip install llama-index)","Document collection (PDF, text, web pages, etc.)","Embedding model (OpenAI, local, or Hugging Face)","LLM API access (OpenAI, Anthropic, or local)"],"input_types":["text (agent task, documents)","structured data (document metadata, retrieval parameters)"],"output_types":["agent reasoning with source citations","retrieved document chunks","synthesis results"],"categories":["memory-knowledge","search-retrieval","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_4","uri":"capability://planning.reasoning.stateful.agent.orchestration.with.langgraph.stategraph.and.conditional.routing","name":"stateful agent orchestration with langgraph stategraph and conditional routing","description":"Teaches LangGraph's explicit state management approach where agents are modeled as directed graphs with nodes representing processing steps and edges representing conditional transitions. The course explains how StateGraph maintains typed state across agent steps, enabling complex workflows with branching logic, loops, and human-in-the-loop interventions. Unlike implicit state in other frameworks, LangGraph requires explicit state schema definition and transition rules, making agent flow transparent and debuggable. Includes patterns for error recovery, state persistence, and multi-agent coordination through shared state graphs.","intents":["Design agents with explicit, debuggable state transitions and conditional logic","Implement complex workflows requiring loops, branching, or human approval steps","Build multi-agent systems that coordinate through shared state graphs","Persist agent state across sessions for long-running or resumable workflows"],"best_for":["Teams building complex workflows with explicit state management requirements","Applications requiring human-in-the-loop approval or intervention","Multi-agent systems with coordinated reasoning and state sharing","Projects where agent flow transparency and debuggability are critical"],"limitations":["Explicit state schema definition adds upfront complexity compared to implicit state in other frameworks","Graph-based approach requires thinking in terms of nodes and edges, steeper learning curve","State persistence requires external storage (database, file system); no built-in persistence","Conditional routing logic can become complex for agents with many decision points"],"requires":["Python 3.9+","langgraph library (pip install langgraph)","Understanding of directed graphs and state machines","LLM API access (OpenAI, Anthropic, or local)","Optional: external state store (Redis, PostgreSQL, etc.) for persistence"],"input_types":["text (agent task, state schema)","structured data (state objects, transition rules)"],"output_types":["state graph visualization","agent execution trace with state transitions","final state object"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_5","uri":"capability://tool.use.integration.function.calling.schema.definition.and.multi.provider.llm.binding","name":"function calling schema definition and multi-provider llm binding","description":"Teaches how to define tool schemas using JSON Schema or Python type hints that enable LLMs to invoke functions reliably. The course covers how different LLM providers (OpenAI, Anthropic, Hugging Face) implement function calling differently (OpenAI uses tool_choice, Anthropic uses tool_use blocks, open-source models require prompt engineering), and how agent frameworks abstract these differences. Includes patterns for schema validation, error handling when LLMs generate invalid function calls, and optimizing schemas to reduce hallucination (e.g., using enums instead of free-text fields).","intents":["Define tool schemas that LLMs can reliably invoke without hallucination","Support function calling across multiple LLM providers with a single agent codebase","Validate and handle LLM-generated function calls that violate schema constraints","Optimize tool schemas to reduce ambiguity and improve LLM accuracy"],"best_for":["Developers building agents that must work across multiple LLM providers","Teams optimizing agent reliability by reducing function calling errors","Projects with strict schema validation requirements (financial, medical, etc.)"],"limitations":["Schema design requires domain expertise; poorly designed schemas lead to high hallucination rates","Provider-specific function calling implementations add complexity when switching models","Open-source models have limited function calling support; often require prompt engineering instead","Schema validation adds latency (~50-100ms per function call) for error checking"],"requires":["Python 3.9+","JSON Schema knowledge or Python type hints","API keys for target LLM providers (OpenAI, Anthropic, Hugging Face, etc.)","Understanding of LLM function calling capabilities and limitations"],"input_types":["Python function definitions or JSON Schema","tool descriptions and parameter documentation"],"output_types":["validated function calls","schema error messages","function execution results"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_6","uri":"capability://code.generation.editing.fine.tuning.llms.for.improved.function.calling.and.agent.reasoning","name":"fine-tuning llms for improved function calling and agent reasoning","description":"Teaches techniques for fine-tuning LLMs to improve their ability to invoke functions correctly and reason through multi-step agent tasks. The course covers dataset preparation (collecting agent trajectories with correct function calls), training approaches (supervised fine-tuning on function calling examples), and evaluation metrics (function call accuracy, reasoning quality). Includes patterns for using synthetic data generation to create fine-tuning datasets when real agent logs are unavailable, and how to measure improvements in agent performance post-fine-tuning.","intents":["Improve agent reliability by fine-tuning LLMs on domain-specific function calling patterns","Reduce hallucination in function calls by training on correct schema usage","Adapt open-source models for specific agent tasks without relying on proprietary APIs","Measure and validate improvements in agent reasoning quality after fine-tuning"],"best_for":["Teams with large agent deployment volumes where fine-tuning ROI is high","Projects using open-source models that need improved function calling","Organizations with domain-specific agent tasks requiring specialized reasoning"],"limitations":["Fine-tuning requires substantial labeled data (1000+ examples); expensive to collect manually","Training infrastructure and compute costs are significant; not suitable for small-scale projects","Fine-tuned models may overfit to training distribution; generalization to new tasks is limited","Evaluation requires running full agent loops; slow feedback cycle compared to supervised learning"],"requires":["Python 3.9+","GPU access (NVIDIA A100 or equivalent) for training","Large dataset of agent trajectories (1000+ examples minimum)","Fine-tuning framework (Hugging Face Transformers, LLaMA Factory, etc.)","Evaluation infrastructure for agent benchmarking"],"input_types":["agent trajectories (task, thought, action, observation sequences)","function call examples with correct schemas","reasoning traces"],"output_types":["fine-tuned model weights","evaluation metrics (function call accuracy, reasoning quality)","performance comparison vs. base model"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_7","uri":"capability://planning.reasoning.agent.observability.tracing.and.evaluation.against.benchmarks","name":"agent observability, tracing, and evaluation against benchmarks","description":"Teaches techniques for monitoring agent behavior, tracing execution paths, and evaluating agent quality against standardized benchmarks. The course covers logging agent steps (thought, action, observation), visualizing agent decision trees, and using benchmarks like GAIA (General AI Assistant) to measure agent reasoning quality. Includes patterns for identifying failure modes (e.g., tool hallucination, reasoning loops), debugging agent behavior through execution traces, and comparing agent performance across frameworks and model choices.","intents":["Monitor agent behavior in production to detect failures and performance degradation","Debug agent reasoning by tracing execution paths and identifying decision points","Evaluate agent quality using standardized benchmarks (GAIA, etc.)","Compare agent implementations across frameworks and models using consistent metrics"],"best_for":["Teams deploying agents to production requiring monitoring and debugging","Researchers evaluating agent architectures and comparing approaches","Projects with strict quality requirements (financial, medical, etc.)"],"limitations":["Tracing adds overhead (~10-20% latency increase) to agent execution","Benchmark evaluation requires manual annotation for ground truth; expensive and time-consuming","Observability tools are framework-specific; switching frameworks requires re-instrumentation","No standardized observability format across agent frameworks"],"requires":["Python 3.9+","Observability framework (LangSmith, Arize, custom logging, etc.)","Benchmark dataset (GAIA, etc.) or custom evaluation set","Metrics definition and evaluation infrastructure"],"input_types":["agent execution logs","benchmark tasks and ground truth answers","agent outputs"],"output_types":["execution traces with decision trees","performance metrics (accuracy, latency, cost)","failure analysis and debugging information"],"categories":["planning-reasoning","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_8","uri":"capability://memory.knowledge.agentic.rag.with.alfred.document.aware.agent.reasoning.and.synthesis","name":"agentic rag with alfred: document-aware agent reasoning and synthesis","description":"Teaches a specific agent application pattern called 'Agentic RAG' where agents actively decide which documents to retrieve and how to synthesize information across multiple sources, rather than passively using retrieved context. The course uses Alfred (a document-aware agent) as a concrete example, showing how agents can reason about document relevance, ask follow-up questions to refine retrieval, and synthesize contradictory information from multiple sources. Includes patterns for handling document uncertainty, managing context windows when dealing with large retrieved sets, and optimizing retrieval strategies based on agent reasoning.","intents":["Build agents that actively manage document retrieval rather than passively using retrieved context","Implement agents that reason about document relevance and ask clarifying questions","Handle contradictory information across multiple documents through agent reasoning","Optimize retrieval strategies based on agent reasoning about information needs"],"best_for":["Teams building research assistants, knowledge base agents, or document analysis tools","Projects requiring agents to reason about document quality and relevance","Applications where passive RAG fails due to complex information synthesis needs"],"limitations":["Agentic RAG adds multiple retrieval steps, increasing latency (2-5s per agent step vs. 500ms for passive RAG)","Requires careful prompt engineering to avoid infinite retrieval loops or over-reliance on documents","More expensive than passive RAG due to multiple LLM calls and retrievals per agent step","Harder to debug than passive RAG because retrieval decisions are implicit in agent reasoning"],"requires":["Python 3.9+","LlamaIndex or similar RAG framework","Document collection with good indexing","LLM API access (OpenAI, Anthropic, or local)","Understanding of agent reasoning patterns"],"input_types":["text (agent task, documents)","structured data (document metadata, retrieval parameters)"],"output_types":["agent reasoning with document citations","synthesis of information across multiple documents","retrieval decisions and justifications"],"categories":["memory-knowledge","planning-reasoning","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-huggingface--agents-course__cap_9","uri":"capability://planning.reasoning.multi.agent.pok.mon.battle.simulation.with.competitive.agent.reasoning","name":"multi-agent pokémon battle simulation with competitive agent reasoning","description":"Teaches agent design through a concrete game-playing application where agents control Pokémon in battles, requiring real-time decision-making, opponent modeling, and strategic reasoning. The course walks through building agents that evaluate game state, predict opponent moves, and select optimal actions (attack, switch, item use) under uncertainty. This application demonstrates agent capabilities beyond text generation: state management (game board), multi-step planning (battle strategy), and competitive reasoning (opponent modeling). Includes patterns for handling imperfect information, managing agent state across multiple turns, and evaluating agent performance through win rates.","intents":["Understand how agents make decisions in dynamic, competitive environments","Learn state management patterns for turn-based games and simulations","Implement opponent modeling and strategic reasoning in agents","Evaluate agent performance through game-based metrics (win rate, strategy quality)"],"best_for":["Developers learning agent design through game-playing applications","Teams building game AI or simulation-based agents","Projects requiring competitive reasoning and opponent modeling"],"limitations":["Pokémon battle simulation is a simplified game; real games have more complex state spaces","Agent performance depends heavily on LLM quality; weaker models make poor strategic decisions","Simulation-based evaluation is slow; full tournament evaluation requires many game iterations","Game-specific patterns may not generalize to other agent applications"],"requires":["Python 3.9+","Pokémon battle simulation framework (provided in course)","LLM API access (OpenAI, Anthropic, or local)","Understanding of agent reasoning patterns"],"input_types":["game state (Pokémon teams, health, status effects)","available actions (attacks, switches, items)"],"output_types":["agent action selection","game outcome (win/loss)","battle transcript with reasoning"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":50,"verified":false,"data_access_risk":"high","permissions":["Basic Python proficiency (3.8+)","Familiarity with transformer models and LLM APIs","Access to LLM providers (OpenAI, Anthropic, or Hugging Face models)","Python 3.9+","Installation of target framework (smolagents, llama-index, langgraph)","Understanding of agent fundamentals from Unit 1","GAIA benchmark dataset (publicly available)","Agent implementation to evaluate","LLM API access (OpenAI, Anthropic, or local)","Evaluation infrastructure (metrics computation, result tracking)"],"failure_modes":["Course material is static and does not adapt to learner pace or background","No built-in sandbox environment for hands-on experimentation during lessons","Multilingual content coverage is incomplete (primarily English with partial Chinese translations)","Comparison is educational rather than performance-benchmarked; no latency or throughput metrics provided","Does not cover framework integration patterns (e.g., using LangGraph with LlamaIndex RAG)","Framework versions taught may lag behind latest releases; requires manual updates","GAIA benchmark is fixed; doesn't adapt to domain-specific agent tasks","Benchmark evaluation is expensive (multiple LLM calls per task); costs scale with agent complexity","Benchmark results may not correlate with real-world agent performance in specific domains","Benchmark tasks are primarily text-based; limited coverage of multimodal or specialized agent tasks","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7577572814601025,"quality":0.34,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.550Z","last_scraped_at":"2026-05-03T13:58:24.501Z","last_commit":"2026-04-27T08:01:55Z"},"community":{"stars":28344,"forks":2044,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=huggingface--agents-course","compare_url":"https://unfragile.ai/compare?artifact=huggingface--agents-course"}},"signature":"xP+qj4e/zbR62gy3tzkJoFaPnHnl7fKtDt1rjUhDcIynhrB/hP5iiX2Je15aFTpe8NIgtAntikrpg9DV64MRDQ==","signedAt":"2026-06-22T13:09:36.019Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/huggingface--agents-course","artifact":"https://unfragile.ai/huggingface--agents-course","verify":"https://unfragile.ai/api/v1/verify?slug=huggingface--agents-course","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}