AI Engineer · Published 2026-08-20

How I automate my own job at Hugging Face using agents — Niels Rogge, Hugging Face

Open on YouTube ↗

Summary

Overview

  • Speaker: Niels Rogge
  • Channel: AI Engineer
  • Main topic: Automating community science workflows and GitHub outreach at Hugging Face using AI agents and language models
  • Purpose: To demonstrate practical agentic automation workflows applied to real-world machine learning engineering tasks, highlighting tooling choices, architecture, prompt management, and scaling strategies. Niels Rogge, Machine Learning Engineer at Hugging Face, explains how he automated a major part of his job—processing trending research papers and community artifacts—using AI agents, LLMs, GitHub Actions, and inference providers like GLM-5.2 and Modal. He discusses the shift from static workflows to flexible AI agents, the importance of eval and tracing tools like Langfuse, and how automating GitHub issue creation and follow-ups leads to scalable community science on the Hugging Face Hub.

Topic Map

Introduction & Community Science Team at Hugging Face

  • Explanation: Niels introduces himself, his background at KU Leuven, and his 5-year tenure at Hugging Face. He defines the Community Science team's role and the problem of fragmented research artifacts scattered across Google Drive, Dropbox, and GitHub releases.
  • Key claims:
    • Researchers often host model weights and datasets on third-party services like Google Drive, hurting discoverability.
    • The Hugging Face Hub acts as a centralized platform with free hosting, model cards, datasets cards, and dedicated SDKs.
  • Examples:
    • Researchers sharing weights on Google Drive links in arXiv README files.
    • Migrating Google Drive weights to Hugging Face Hub repos.
  • Terminology:
    • Community Science
    • Model Cards
    • Dataset Cards
    • Hugging Face Hub
  • Why it matters: Decentralized model artifacts reduce discoverability and reproducibility of AI research.

Scaling Community Science via Automation

  • Explanation: Explaining the manual outreach process via GitHub issues and PRs, and the bottleneck caused by the explosion of AI research papers during the AI boom.
  • Key claims:
    • Manually opening GitHub issues for hundreds of daily arXiv papers is not scalable.
    • Automation requires an AI agent to handle research paper parsing, GitHub URL discovery, README reading, and author outreach.
  • Examples:
    • Opening GitHub issues to request checkpoint migration to Hugging Face Hub.
    • Opening Pull Requests to add model and dataset cards.
  • Terminology:
    • GitHub Issues
    • Pull Requests
    • arXiv
    • Outreach Workflow
  • Why it matters: Manual curation cannot keep pace with the exponential growth of academic paper publications.

Workflows vs. AI Agents

  • Explanation: Comparing structured, deterministic workflows with fully autonomous LLM loops, and explaining the architectural decision to use a deterministic pipeline combined with LLM API calls.
  • Key claims:
    • Workflows offer predictability, simpler management, and deterministic step sequencing.
    • AI agents offer greater flexibility but lower predictability.
    • Anthropic's guidance suggests starting simple, avoiding complex agent frameworks when unnecessary, and using Unix primitives.
  • Examples:
    • Excalidraw MCP server workflow pipeline with 8 distinct steps.
    • Claude Agent SDK and Cursor 200-line code simplification examples.
  • Terminology:
    • Deterministic Workflow
    • Autonomous Agent
    • LLM Cell
    • Anthropic Agent SDK
  • Why it matters: Architects must balance predictability and flexibility based on use case constraints.

Deployment, Tracing, and Results

  • Explanation: Details on deploying the agent using GitHub Actions Cron jobs and Modal batch processing, tracing with Langfuse, and analyzing community response metrics.
  • Key claims:
    • Modal batch processing allows spinning up massive containers in parallel for each GitHub issue.
    • Langfuse provides robust tracing, cost tracking, latency monitoring, and prompt observability.
    • Out of thousands of automated outreach interactions, negative community feedback was negligible (only two negative comments).
  • Examples:
    • DailyPapers X/Twitter bot deployment with over 90,000 followers.
    • Modal container execution logs showing successful batch processing of arXiv papers every night.
  • Terminology:
    • Modal
    • Langfuse
    • GitHub Actions
    • Cron Job
    • GLM-5.2
  • Why it matters: Serverless batch processing and tracing make background agent execution reliable and cost-effective.

Key Points

Centralization of Research Artifacts

  • Explanation: Migrating model checkpoints and datasets from Google Drive to Hugging Face Hub improves discovery, metadata tagging, and reproducibility.
  • Evidence: Paper pages on Hugging Face automatically link associated models and datasets sourced from arXiv.
  • Practical implication: Researchers gain better promotion and visibility for their work.

Deterministic Workflows Over Complex Agent Frameworks

  • Explanation: Following Anthropic's recommendations, starting with a structured multi-step pipeline using LLM APIs provides higher reliability than black-box agent frameworks.
  • Evidence: An 8-step Excalidraw-driven pipeline handles paper parsing, URL discovery, README reading, artifact classification, and voting.
  • Practical implication: Easier debugging, predictable execution, and lower maintenance overhead.

Serverless Batch Deployment with Modal

  • Explanation: Deploying agent loops as cron jobs using GitHub Actions and Modal batch processing enables parallel execution across hundreds of papers overnight.
  • Evidence: Modal processes each GitHub issue in a separate container with fast startup times and robust scalability.
  • Practical implication: Zero server management and cost-efficient background task automation.

Observability and Evaluation with Langfuse

  • Explanation: Using Langfuse for tracing provides visibility into LLM inputs, outputs, prompts, latency, and costs.
  • Evidence: Dashboard tracking shows token usage and model execution traces across nightly cron runs.
  • Practical implication: Rapid identification of prompt failures and cost optimization.

Frameworks, Models & Processes

Single Paper Processing Pipeline (main.py)

  • How it works: A deterministic multi-step pipeline executed nightly via cron job to parse arXiv papers and interact with GitHub.
  • Components:
    • Step 1: Find URLs (arXiv paper parsing, PDF extraction)
    • Step 2: Project -> GitHub (Read README)
    • Step 3: Check for artifacts
    • Step 4: Majority Vote (LLM consensus)
    • Step 5: GitHub Issue / PR creation
    • Step 7: Persist (Merge results into Hub)
  • When to use: When automating repetitive web/GitHub research curation tasks where predictability is required.

Examples & Case Studies

PaddleOCR migrated all OCR models to Hugging Face based on automated outreach agent issues.

  • Illustrates: Successful large-scale adoption of automated hub integration by external organizations.
  • Lesson: AI agents can effectively scale developer relations and community outreach.

DailyPapers X account automatically shares popular research papers and artifacts every 4 hours.

  • Illustrates: Autonomous social media curation powered by LLM visual selection and paper tracking.
  • Lesson: Automated agents can drive massive audience reach (90k+ followers) without manual intervention.

Actionable Takeaways

  • Immediate:
    • Use GitHub Actions and Modal for low-cost, serverless cron job execution of LLM agents.
    • Implement tracing tools like Langfuse for LLM observability and debugging.
    • Start with structured, deterministic workflows before adopting complex autonomous agent loops.
  • Strategic:
    • Open-source models (like GLM-5.2 and DeepSeek-v4) are competitive with proprietary frontier models for specialized agent tasks.
    • Automating community outreach can dramatically accelerate platform adoption and artifact discoverability.
    • Combining LLM tool use with CLI interfaces (like Hugging Face CLI and Bash) replaces thousands of lines of custom code.
  • Questions to investigate:
    • How to prevent agent spam and ensure high-quality interactions on public platforms?
    • What are the best evaluation metrics (evals) for validating multi-step agent outputs?
    • How to balance agent autonomy with human-in-the-loop review guardrails?

Claims Worth Verifying

  • GLM-5.2 outperforms or matches Opus 4.8 on coding benchmarks while being cheaper. (Benchmark claim)
  • DailyPapers X account crossed 90,000 followers with zero manual human involvement. (Metric claim)

Notable Quotes

"How I automate my own Job at Hugging Face with agents" (at 0:22) "Try to avoid building agents if you really don't have to. Start simple, start with a single LLM API." (at 10:12)

Compressed Summary

  • Automated community science workflows at Hugging Face using LLM agents and deterministic pipelines.
  • Replaced manual GitHub issue creation and PR follow-ups with nightly cron jobs.
  • Leveraged Modal for serverless batch processing and Langfuse for LLM tracing.
  • Demonstrated that open models like GLM-5.2 match frontier capabilities for agentic coding tasks.
  • Achieved 90k+ followers on @DailyPapers through fully automated research curation.
  • Keywords: agents, automation, huggingface, github, workflow, modal
  • Core insight: Combining deterministic multi-step workflows with open-source LLMs and serverless batch execution allows engineers to automate large-scale community science and outreach reliably.

Core insights

6
Architecturemedium noveltystrong evidence

The production system is a deterministic multi-step pipeline (~8 steps) with bounded LLM calls embedded as individual steps (an 'LLM cell'), not an autonomous agent loop — orchestration lives in code, while the model is invoked only for narrow sub-decisions such as artifact classification and voting.

Why it matters

It inverts the default 'give the model tools and a loop' design: control flow, retries, and state transitions stay in ordinary code, so failures are localized to specific steps and can be debugged without reasoning about emergent agent trajectories. It also reduces framework surface area and maintenance cost.

Generalization

For high-volume, repetitive curation/extraction tasks, put the probabilistic component at the smallest possible decision boundary and keep orchestration deterministic; treat agent frameworks as an option only when step boundaries cannot be enumerated in advance.

A deterministic multi-step pipeline executed nightly via cron job to parse arXiv papers and interact with GitHub.
Open source video
An 8-step Excalidraw-driven pipeline handles paper parsing, URL discovery, README reading, artifact classification, and voting.
Open source video
Anthropic's guidance suggests starting simple, avoiding complex agent frameworks when unnecessary, and using Unix primitives.
Open source video
Mechanismmedium noveltymoderate evidence

The pipeline includes an explicit 'Majority Vote (LLM consensus)' step — artifact classification is decided by aggregating multiple LLM judgments rather than a single call.

Why it matters

Self-consistency voting is used as the reliability layer for a step whose output triggers irreversible external side effects (opening a GitHub issue or PR on someone else's repo). It is a concrete, low-complexity alternative to fine-tuning or a heavier verification agent.

Generalization

Where an LLM decision gates an externally visible or hard-to-reverse action, sample multiple judgments and require agreement before acting; the vote count becomes a tunable precision/recall knob.

Step 4: Majority Vote (LLM consensus)
Open source video
Practicemedium noveltystrong evidence

Deployment couples a GitHub Actions cron trigger with Modal batch processing so that each GitHub issue is handled in its own parallel container for the nightly arXiv sweep.

Why it matters

This is a reusable pattern for turn-based, embarrassingly parallel agent workloads: serverless fan-out gives per-item isolation and fast container startup without maintaining a queue, worker pool, or scheduler.

Generalization

Batch-agent workloads whose items are independent should be dispatched as one container per item from a cron trigger rather than a long-running agent process, trading orchestration complexity for isolation and elastic parallelism.

Modal batch processing allows spinning up massive containers in parallel for each GitHub issue.
Open source video
Modal processes each GitHub issue in a separate container with fast startup times and robust scalability.
Open source video
Deploying agent loops as cron jobs using GitHub Actions and Modal batch processing enables parallel execution across hundreds of papers overnight.
Open source video
Empirical Resulthigh noveltymoderate evidence

Despite thousands of automated outbound interactions with external maintainers, only two negative community comments were reported.

Why it matters

It is direct evidence against the common assumption that automated agent outreach at scale will be perceived as spam or damage the operator's reputation — but the result is conditional on the message quality and the legitimacy of the ask, not on automation per se.

Generalization

Trust cost of agent outreach may be dominated by content relevance and targeting precision rather than by the fact that a machine authored it; teams should measure backlash as an explicit metric before assuming a human-in-the-loop requirement.

Out of thousands of automated outreach interactions, negative community feedback was negligible (only two negative comments).
Open source video
Practicelow noveltymoderate evidence

Tracing is treated as first-class production infrastructure: Langfuse is used for prompt-level input/output visibility plus cost, latency, and token tracking across nightly runs.

Why it matters

In a deterministic pipeline, traces are the only way to see inside the LLM cells; without them, a bad prompt produces silent quality degradation that is invisible in step-level success metrics. Cost tracking also matters because the workload scales with the daily paper firehose.

Generalization

Any scheduled LLM pipeline needs prompt-version-level observability (inputs, outputs, tokens, cost, latency) wired in before it runs unattended, because the failure mode is degraded accuracy rather than hard errors.

Langfuse provides robust tracing, cost tracking, latency monitoring, and prompt observability.
Open source video
Dashboard tracking shows token usage and model execution traces across nightly cron runs.
Open source video
Mental Modellow noveltystrong evidence

The automation is scoped to a scaling bottleneck (manual GitHub outreach cannot absorb the volume of daily arXiv papers), and the agentized work is explicitly decomposed into parsing, URL discovery, README reading, artifact classification, and outreach.

Why it matters

Framing the target as a volume constraint rather than a capability gap determines which parts get automated first and what 'success' means (throughput, not novelty of behavior). It also explains why the design can stay deterministic — the task taxonomy is known.

Generalization

Automate volume-limited, enumerable workflows before exploratory ones; if the step list is knowable, a pipeline will outperform an agent on cost, reliability, and debuggability.

Manually opening GitHub issues for hundreds of daily arXiv papers is not scalable.
Open source video
Automation requires an AI agent to handle research paper parsing, GitHub URL discovery, README reading, and author outreach.
Open source video

Deep dives

4

Deterministic pipelines vs autonomous agents for high-volume automation

Research question

For high-volume, enumerable workflows, when does a deterministic pipeline with embedded LLM calls outperform an autonomous agent loop in reliability, cost, and debuggability?

Why

It determines the default architecture for production automation where the step list is known, avoiding framework overhead and emergent failure modes.

explaining the architectural decision to use a deterministic pipeline combined with LLM API calls.
Open source video
Workflows offer predictability, simpler management, and deterministic step sequencing.
Open source video
AI agents offer greater flexibility but lower predictability.
Open source video
Source video

Observability and eval for unattended LLM pipelines

Research question

What minimal tracing and evaluation infrastructure is required to detect prompt regressions in a nightly LLM pipeline before they cause external side effects?

Why

Unattended pipelines fail silently through degraded accuracy, so observability is the only substitute for human supervision.

the importance of eval and tracing tools like Langfuse
Open source video
using AI agents, LLMs, GitHub Actions, and inference providers like GLM-5.2 and Modal.
Open source video
Source video

Trust and backlash from automated agent outreach

Research question

What factors (targeting precision, message quality, volume) predict community backlash for automated outreach at scale, and can backlash be reduced to near zero by improving precision without human-in-the-loop?

Why

It challenges the default assumption that automated outreach risks reputation, and suggests measurable precision controls can replace human review.

Manually opening GitHub issues for hundreds of daily arXiv papers is not scalable.
Open source video
how automating GitHub issue creation and follow-ups leads to scalable community science on the Hugging Face Hub.
Open source video
Source video

Serverless batch orchestration for agent workloads

Research question

What are the cost, latency, and isolation tradeoffs of dispatching one container per item versus a long-running worker pool for nightly agent batch jobs?

Why

It provides a reusable pattern for embarrassingly parallel agent workloads, removing the need for queue management.

using AI agents, LLMs, GitHub Actions, and inference providers like GLM-5.2 and Modal.
Open source video
Source video

Article ideas

3

Your Agent Should Be a Pipeline: Why Deterministic Orchestration Beats Autonomous Loops for High-Volume Curation

For high-volume, enumerable automation, embedding LLM calls as bounded steps in a deterministic pipeline beats an autonomous agent loop on reliability, cost, and debuggability, and the flexibility lost is irrelevant when the step list is known in advance.

Angle

Architectural argument with tradeoff analysis and concrete examples from a production outreach system.

Source video

The Trust Tax of Automated Outreach: Why Two Negative Comments Out of Thousands Changes the Human-in-the-Loop Calculus

Automated agent outreach at scale can achieve negligible backlash if targeting precision is high, meaning trust cost is dominated by content relevance rather than automation itself; teams should measure backlash explicitly instead of defaulting to human-in-the-loop.

Angle

Empirical counterpoint to the assumption that automated outreach is inherently spammy, with metrics on backlash and precision.

Source video

Observability Is the Safety Mechanism for Unattended LLM Pipelines

For scheduled LLM pipelines that produce external side effects, prompt-level tracing and replayable eval sets are the primary safety mechanism, because failures manifest as silent quality degradation rather than errors.

Angle

Operational deep dive into tracing, cost tracking, and eval gating for nightly batch pipelines.

Source video

Project ideas

4

VoteGate

gatehouse

For LLM classification steps that gate irreversible external actions (e.g., opening a GitHub issue), a k-sample majority vote (k=3 or 5) reduces false positives by at least 50% compared to a single call, at a token cost increase roughly linear in k.

Proof of concept

Implement an artifact classifier that decides whether a GitHub repo contains a model checkpoint worth migrating. Run single call vs 3-sample and 5-sample majority vote on 100 labeled examples. Measure precision, recall, and token cost.

Measurement

Precision lift and cost multiplier.

Source video

TraceEval

beyond-evals

A small labeled eval set (50 examples) replayed on each nightly run, combined with trace logging, detects prompt/model regressions before they produce external side effects, with lower false alarm rate than monitoring downstream community feedback.

Proof of concept

Build a GitHub Action that runs the eval set after each pipeline run, compares accuracy to a baseline, and alerts on degradation beyond a threshold. Inject a deliberate prompt regression and measure detection latency.

Measurement

Time to detect a deliberately injected prompt regression, and false alarm rate over 30 runs.

Source video

OutreachAudit

movement-lab

Community backlash from automated outreach is primarily driven by false-positive targeting (contacting repos without relevant artifacts) rather than by the automated nature of the message; a content-based precision filter reduces negative comments per thousand messages by at least 80% at equal volume.

Proof of concept

Instrument an automated outreach pipeline to log sent messages and track replies/comments. Run an A/B test: one group gets outreach with a high-precision filter, another without. Measure negative comments per 1000 messages.

Measurement

Negative comments per 1000 outreach messages, and precision of targeting.

Source video

CronFan

new

A serverless fan-out architecture (one container per item) achieves lower per-item latency and comparable cost to a long-running worker pool for nightly batch agent workloads, while simplifying failure isolation.

Proof of concept

Implement a batch of 100 agent tasks (e.g., summarizing arXiv papers) using both architectures. Measure wall-clock time, cost, and error recovery.

Measurement

Wall-clock time and cost per item, and time to recover from a failed item.

Source video

Architectural implications

2

Probabilistic reasoning is confined to discrete pipeline steps rather than controlling the whole run.

Before

A single autonomous agent with tools decides what to do next across the entire task.

After

Fixed step sequence in code; each LLM invocation is a bounded classification/extraction call with its own inputs and outputs.

Consequence

Failures become attributable to a step and a prompt version, retries and fallbacks can be coded per step, and the system remains testable piecewise — at the cost of losing the ability to handle tasks whose steps are not known in advance.

Source video

Outbound side effects on external repositories are produced by unattended batch jobs.

Before

A human engineer reads a paper, finds the repo, and writes the issue or PR by hand.

After

Nightly cron job fans out container-per-issue work through Modal and creates issues/PRs automatically.

Consequence

The engineering burden shifts from doing the outreach to designing precision controls (voting, tracing, prompt review) that keep false positives from reaching real maintainers, since errors now ship at machine volume.

Source video

Tradeoffs and failure modes

3

Deterministic workflow vs autonomous agent

Benefit

Predictability, simpler management, deterministic step sequencing, easier debugging.

Cost or risk

Lower flexibility: novel or shifting task structures cannot be handled without changing code, and the pipeline cannot adapt mid-run.

AI agents offer greater flexibility but lower predictability.
Open source video
Source video

Majority-vote LLM consensus on a decision step

Benefit

Higher decision reliability before triggering irreversible external actions such as opening issues or PRs.

Cost or risk

Multiple model calls per item multiply token cost and latency across the nightly batch, and correlate errors can still defeat the vote.

Step 4: Majority Vote (LLM consensus)
Open source video
Source video

Automated large-scale outbound outreach

Benefit

Reaches a volume of papers and repos that manual curation cannot, with negligible reported negative feedback (two negative comments out of thousands).

Cost or risk

A single systematic prompt flaw or false-positive pattern propagates to thousands of external repos before it is caught, so prompt and evaluation discipline is the primary safety control rather than human review.

Out of thousands of automated outreach interactions, negative community feedback was negligible (only two negative comments).
Open source video
Source video

Open questions

4

How many samples and what agreement threshold constitute the majority vote, and how does accuracy scale with vote count?

Why unresolved

The summary names the step but gives no vote count, aggregation rule, or measured precision/recall before and after voting.

Research direction

Benchmark single-call vs k-sample majority vote on the artifact-classification task, plotting precision on the downstream GitHub issue action against token cost.

Source video

What is the false-positive rate of automated issue/PR creation, and how would a maintained repo detect and reverse a bad outreach?

Why unresolved

Only negative-comment counts are reported; no precision metric or rollback mechanism is described.

Research direction

Instrument generated outreach with a human-labeled audit sample and build a retraction/undo path for wrongly created issues.

Source video

Does the deterministic pipeline generalize to tasks whose step boundaries are not known in advance, or is it specific to arXiv-to-GitHub curation?

Why unresolved

All evidence comes from a single workflow family with a stable, enumerable step list.

Research direction

Attempt the same design on a task with shifting tool requirements and measure where a fixed pipeline breaks down and an agent loop is forced.

Source video

How are prompt regressions detected automatically between nightly runs, rather than discovered via downstream community reaction?

Why unresolved

Langfuse provides traces and cost/latency visibility, but the summary does not describe automated quality evaluation or alerting on output quality.

Research direction

Pair traces with a small labeled eval set replayed each run to gate prompt/model changes before deployment.

Source video

Key claims

8
comparativeVerification needed

Workflow and agent architectures sit on a predictability-versus-flexibility tradeoff, with workflows favored for deterministic sequencing.

Evidence

Workflows offer predictability, simpler management, and deterministic step sequencing.

Question

In which task classes does the agent's added flexibility produce measurably better outcomes than a fixed pipeline at equal cost?

Source video
opinionVerification not requested

Starting simple and avoiding complex agent frameworks when unnecessary, leaning on Unix primitives, is the recommended path.

Evidence

Anthropic's guidance suggests starting simple, avoiding complex agent frameworks when unnecessary, and using Unix primitives.

Source video
causalVerification needed

Manual GitHub issue creation for hundreds of daily arXiv papers is not scalable, motivating automation of parsing, URL discovery, README reading, and outreach.

Evidence

Manually opening GitHub issues for hundreds of daily arXiv papers is not scalable.

Question

What was the actual manual throughput ceiling before automation, and what is the automated throughput now?

Source video
factualVerification needed

Modal batch processing runs each GitHub issue in a separate container in parallel with fast startup and scalable execution.

Evidence

Modal processes each GitHub issue in a separate container with fast startup times and robust scalability.

Question

What are the per-container startup latency and the cost per processed paper at nightly batch scale?

Source video
factualVerification needed

Langfuse supplies tracing, cost tracking, latency monitoring, and prompt observability for the nightly LLM runs.

Evidence

Langfuse provides robust tracing, cost tracking, latency monitoring, and prompt observability.

Question

Which concrete failure was diagnosed via traces that would have gone undetected with only step-level logs?

Source video
factualVerification needed

Automated outreach produced negligible negative community feedback at scale.

Evidence

Out of thousands of automated outreach interactions, negative community feedback was negligible (only two negative comments).

Question

How was 'negative feedback' measured, and how many recipients silently ignored or privately resented the outreach?

Source video
causalVerification needed

Researchers frequently host weights and datasets on third-party services such as Google Drive, reducing discoverability relative to the Hugging Face Hub.

Evidence

Researchers often host model weights and datasets on third-party services like Google Drive, hurting discoverability.

Question

Does migration to the Hub measurably increase citations, downloads, or reproduction attempts for the affected papers?

Source video
factualVerification needed

External organizations adopted the automated outreach output at scale, as with PaddleOCR migrating all OCR models to Hugging Face based on agent-created issues.

Evidence

PaddleOCR migrated all OCR models to Hugging Face based on automated outreach agent issues.

Question

What fraction of automated outreach issues result in actual migration or PR acceptance versus being closed or ignored?

Source video

Connections

3