Niels Rogge has built a machine that does his job for him. It reads research papers, tracks down their authors, opens GitHub issues asking them to publish their models and datasets on Hugging Face, and then follows up when they respond. It has done this thousands of times. Only two people have ever complained. And Rogge has made a deliberate choice that many will find uncomfortable: he does not tell the researchers they are talking to a bot.

The machine learning engineer, who has spent five years at Hugging Face, laid out his system in detail on the AI Engineer podcast in August 2026. It is one of the clearest real-world case studies yet of what happens when an engineer decides to automate their own job in the age of capable large language models. The job does not disappear. It changes — from doing the work to building and monitoring the machine that does it.

The Problem: Hundreds of Papers a Day, One Human

Rogge’s role on Hugging Face’s community science team starts with a discovery problem. Researchers publish model weights and datasets all over the internet — Google Drive, GitHub releases, Dropbox, Zenodo — places that are hard to find, hard to cite, and hard to reproduce. Hugging Face offers a centralized alternative with paper pages linked to arXiv, metadata tags for filtering by task or language, and documentation cards.

His job was to convince researchers to migrate. The manual workflow was straightforward: find a paper, locate its repository, read the README, check whether the artifacts were already on the Hub, and if not, open a GitHub issue. Then follow up. But the volume made it unsustainable.

“It’s not really scalable for me to open all these GitHub issues or pull requests because every single day there are like hundreds of research papers coming out on arXiv especially now with AI boom,” Rogge noted.

Phase One: The Conservative Workflow

His first automation attempt, built in 2024, followed the prevailing wisdom of the time. Rogge cited Anthropic’s blog post Building Effective Agents as his guide — specifically its advice to avoid building agents when you don’t have to, start with a single LLM API, and steer clear of frameworks.

The result was a deterministic workflow: a Python script scheduled through GitHub Actions that read arXiv papers, extracted GitHub URLs, checked the Hugging Face Hub for existing artifacts, and opened issues or pull requests. Each step was an LLM call in a fixed pipeline. No agent loop, no autonomous decision-making. LangFuse provided observability.

It worked. Hundreds of issues went out every night. But a new bottleneck appeared: the follow-up. Researchers replied to the issues, and Rogge found himself reading and responding to each one manually — a task he described as “kind of like going through your mailbox.”

Phase Two: The Agent That Needs One Skill

The shift came after a workshop at AI Engineer New York in November 2025, where Anthropic presented the Claude Agents SDK and argued that agents might now be better than workflows — a reversal of the guidance Rogge had followed a year earlier. A Cursor talk at AI Engineer London months later reinforced the message: the company had replaced 12,000 lines of custom workflow code with a 200-line skill.

Rogge’s new architecture is strikingly minimal. The agent runs on the Claude Agents SDK in Python. Its only tool is Bash, primarily invoking the Hugging Face CLI. The model is GLM 5.2, accessed through Hugging Face Inference Providers. Deployment happens on Modal, using batch processing to spin up parallel containers — one agent loop per GitHub issue.

“For my use case, I would say agents are actually better than workflows,” Rogge said. “They only need a single CLI, which is a Hugging Face CLI. They need a single skill, the Hugging Face CLI skill and a sandbox and that’s all they need to do their work.”

The agent’s task is to read each GitHub issue, determine whether the researcher has uploaded their artifacts, and if so, compose a follow-up comment. Rogge triggers the pipeline manually through a Cursor skill called “process-under-modal,” but the processing itself is fully autonomous.

The model choice is notable. Rogge switched from Claude models to the open-weight GLM 5.2 the week of the recording, citing its strong performance on Cursor’s benchmark and Post-training Bench, where he said it beats Opus 4.8 at lower cost. “Models have become so good that you might actually now start to work with fully autonomous agents rather than a workflow,” he noted.

Results: Apple, DeepMind, PaddleOCR, and a Dead Internet

The empirical results are striking. Out of thousands of GitHub issues created by his agents, Rogge has received exactly two negative comments. One person asked him to “close this slop.” The majority respond positively, often with messages like “Hi Niels, thanks a lot for your suggestion and the clear guidance.”

The concrete outcomes include:

A researcher from Apple direct-messaged Rogge after his agent opened an issue about publishing Apple paper artifacts on Hugging Face.
Google DeepMind was contacted about publishing mathematics datasets.
PaddleOCR, the Chinese OCR company, migrated its entire model suite to the Hub based on agent-created issues.
The most popular issue, for the paper Tiny Recursive Models, was upvoted by more than 60 people and resulted in the model being released on Hugging Face.
A researcher reached out wanting to publish a 400-gigabyte dataset — a direct result of an agent’s GitHub issue.

The agents also complete model card templates by reading the paper PDF itself, based on Meg Mitchell’s “Model Cards for Model Reporting” framework. In one case, an agent listed “community science team” as the model card authors and included Rogge’s name — something he never prompted. The machine had written his name into the documentation, unprompted.

A recurring pattern has emerged: researchers are now using their own agents to reply to Rogge’s agents. “Kind of the dead internet nowadays,” he observed.

The Disclosure Question

Rogge is candid about a decision that will divide opinion. His agents do not identify themselves as bots.

“I don’t disclose that it’s an agent. Why? Because I think if people know it’s a bot then they might quickly like close the issue and to be honest they post exactly the same stuff as I was doing before manually,” he said, adding that he sees no reason to disclose given the identical output.

The ethical framing is practical, not philosophical. The system is a win-win, he argues: researchers get discoverability and documentation; the community gets accessible artifacts. But the asymmetry of information is real. A researcher engaging with what appears to be a thoughtful human colleague is actually talking to GLM 5.2 running in a Modal container.

This tension is amplified by the broader context of autonomous agents proliferating in 2026. Rogge’s agents are increasingly talking to other agents, and neither side necessarily knows it. The “dead internet” he jokes about is, from the researcher’s perspective, indistinguishable from a live one.

The Slop Problem

The question of quality control is where Rogge’s system is most exposed. He acknowledged the concern directly: “You might also wonder how to avoid slop because you might think, okay, you have an agent spamming the whole Internet with your GitHub issues, like should you even do this?”

His answer is a blog post recommendation. He pointed to Hamel Husain’s LLM Evals FAQ as the key resource for evaluating whether an agent’s output is actually good before letting it run at scale. There is no formal eval suite in the system he described. The guardrail is Rogge’s judgment, applied when he reviews results posted to the Hugging Face Slack channel.

This is a notable gap. The system has run for over a year, generated thousands of interactions, and produced measurable outcomes. But its quality assurance rests on a single engineer’s attention span and a link to someone else’s blog post. For anyone replicating this approach at scale, that is the most fragile component.

The Bigger Shift: Open Models Replace Closed

Rogge’s model choice reflects a broader trend in agentic AI. His prediction, stated with high confidence, is that open models “will continue to improve and increasingly replace closed-source models in production agent use cases.”

The economic logic is straightforward. Agent loops are token-hungry. Running thousands of GitHub issue follow-ups on a closed model like Claude Opus would be expensive. GLM 5.2, accessed through Hugging Face’s unified inference provider, delivers comparable performance at a fraction of the cost. Rogge’s own benchmark — the Cursor bench and Post-training Bench — showed GLM 5.2 beating Opus 4.8, he said, at lower cost.

NVIDIA’s involvement adds another data point. A recent tweet about NVIDIA optimizing GLM 5.2 received over 2,000 likes on the Daily Papers account Rogge runs — a signal that the ecosystem around open models is maturing beyond the research community.

Adjacent Projects: Daily Papers and the Papers with Code Revival

Rogge’s automation extends beyond GitHub outreach. His Daily Papers account, which posts interesting research papers from Hugging Face every four hours, recently crossed 90,000 followers with no manual involvement from him. The account uses Gemini to select the best visual for each tweet.

He is also reviving Papers with Code, the website Meta acquired and then let die. The new version at paperswithcode.co includes benchmarks and educational content explaining technical terms. The effort is presented as work in progress, extending Rogge’s mission of making research artifacts more discoverable and understandable.

The Job That Changes

Rogge’s system is not a demo or a pilot. It is a production system that has run for over a year, produced measurable results, and changed the nature of his work. The bottleneck is no longer labor or cost — it is evaluation and judgment.

The trajectory from workflow to agent mirrors the broader industry shift he witnessed at AI Engineer conferences. The same lesson Cursor learned — that a simple skill can replace thousands of lines of deterministic code — applies to community outreach. The constraint that once forced engineers toward predictable, controllable workflows — unreliable models — has dissolved. What remains is a judgment call about when to let the agent run free.

That judgment call now includes ethics. As agent-to-agent communication becomes more common, the norms around disclosure will likely shift. Rogge’s rationale — that disclosure would reduce engagement and that the output is identical to his manual work — is pragmatic but will not satisfy everyone. Systems like this may face reputational or regulatory pressure, particularly as the public grows more skeptical of AI systems they cannot see.

For now, Rogge offers a working example of what happens when one engineer decides to automate their own job. The job does not disappear. It changes — from doing the work to building and monitoring the system that does it. The work that remains is the work no model can do: deciding what to tell people about the machine talking to them.