10 July 202 (Updated: 14 July 2026)
In this tutorial I explore the open-source AI agent “Hermes” and how it can be utilized for digital history tools. First, I provide background information about the agentic coding system “Hermes”. Second, I give insights into the use of vibe coding in the field of digital history. Third, I elaborate on my own experience with vibe coding showcasing three mini projects: (1) Interactive NER Visualizer (2) Interactive NER Visualizer & Tagger 2.0 and (3) A “Data Humanist” Visualization. Finally, I present a list of my main takeaways from working with Hermes to build digital history tools.
Introduction: What is Hermes Agent?
I recently came across what in the tech world is already considered “old news”, which is the open source agentic system “Hermes Agent”. Hermes Agent was developed by the US-based open-source AI research lab Nous Research and is defined by the developers as “an autonomous agent that lives on your server, remembers what it learns, and gets more capable the longer it runs.”
The agent falls under the category of agentic AI systems. These systems are designed to “delegate substantial cognitive and operational responsibility to autonomous or semi-autonomous software agents.” (Sapkota et al., 2025, 4). Simply said, “Hermes Agent” is an LLM with a specific role that performs tasks on your behalf directing other LLMs. Instead of you wrangling the AI yourself, Hermes acts as the autonomous intermediary between you and the models. So, instead of entering a multi-turn conversation with an AI chat interface, such as ChatGPT or Claude Chat, where most of the time you have to go back and forth to come to a satisfying result, you give Hermes a goal, and it works autonomously to achieve it. Though it possesses powerful programming capabilities, Hermes is not just an “agentic coding system”; it is more like a personal assistant, that for instance can schedule, research or perform data analysis. But what does that mean in detail and how does it work? Before I will present a few mini projects in the field of digital history developed using Hermes, I will give you more useful information about the agent itself.
Hermes Agent lives on your computer and you communicate with Hermes in natural language via the command line interface. This means that you access Hermes via your shell/terminal. This also implies that Hermes has access to your computer and files, which in practice means that Hermes can, when asked, move, create, delete, merge, … files, programs or scripts on your computer. Hermes can be connected to your media channels, such as Slack or WhatsApp, your emails, can browse the internet for you, can send messages and emails on your behalf, can generate images or visualizations, and much more. Hermes has a predetermined set of skills. The list of skills is large and can be endlessly stretched. It reaches from creative skills such as popular web design and AI songwriting to data science skills, Github skills, productivity skills, email writing, and so on (more information about skills here).
But the most useful feature, in my opinion, is the memory feature. Hermes learns tasks you asked it to perform and will remember them for future prompts. This feature is especially useful for digital history workflows that, most of the time, require multiple rounds of modifications. I will explain further down, how this feature can be helpful.
To run Hermes, you need to choose a model. This model can be an open source local model or a commercial, bigger and faster model. Which one you choose depends on the tasks you want to perform, the level of privacy you want to maintain, the specs of your computer and what your financial resources are. I initially opted for the Chinese local LLM Qwen 3.5 which worked well for the first experiments I ran. Such experiments involved, for instance, sorting the files in my download folder into several sub-folders or finding files on my computer and moving them from one folder to another. However, as my tasks became more complex and required more tokens, as I started to experiment with digital history workflows, I changed from the Chinese local model Qwen 3.5 to the Chinese model Deepseek V4 Flash. I opted for Deepseek due to its low pricing and its massive token context window of 1 Million (for a comparison of different models and their pricing you can check out openrouter.ai)
How to install and Access Hermes Agent
To use Hermes you need to follow the installation and set up guidelines provided by Nous Research (more information here). The installation process is generally quite straightforward. If you have ever installed a regular software, you should be good to go. However, if you nevertheless run into troubles setting up the agent by yourself, there are plenty of useful Youtube Videos out there, that teach you how to do it in detail.
Once Hermes has been set up, you can open your terminal/shell and type in “Hermes”. The command line interface of Hermes will appear below your text and will look like in the following picture. You can now start interacting with the agent through the command line. Alternatively, you can access Hermes Agent through a Desktop App that runs on Windows, Mac and Linux (more information here).
For a first impression of what Hermes is capable, I would suggest to just experiment with the agent. Let your agent find files on your computer, create visualizations to explain a concept, or dive immediately into the production of little digital history tools. I personally started out by asking the agent in natural language to locate files on my computer or to sort my files in my download folder based on what ever structure it finds most organized. My download folder transformed from a random collection of hundreds of different files in different formats into the following (to be fair, my download folder mostly consists of PDF files from research papers, which took up most of the space):
On another occasion, I was out on a walk when I tried to understand the difference between blue whales and humpback whales a little better. So to give me a visual experience, I asked Hermes (via my WhatsApp) to create this visual for me.
When I came back home, I opened my computer and found the following infographic about whales (note that I did not check the accuracy of the statements made):
Vibe Coding and Digital History
After having spent some time experimenting with Hermes, I was keen to understand what it can do for the field of digital history. To me, the most useful feature of an(y) agentic system is the automation of coding. Whether you have no knowledge of coding, a basic understanding or are proficient, architectures such as Hermes not only accelerate workflows but also debug and provide you with alternative solutions to your problems. However, Hermes can do more. It does not only assist your coding journey, which is incredibly useful but it has a memory feature. What this means is that it remembers workflows and can save them as skills for future tasks. To give an example, I asked Hermes to “Perform NER (named-entity-recognition) on the following text X” . However, I was not satisfied with the result at first, as it did create a CSV list of named entities, but did neither provide the number of occurrences of each entity nor the original text with the tagged entities. Therefore, we iterated the process with the correct instruction. Followingly, I asked Hermes to save this task as a “skill” which it saved as part of the data science skill. So, next time I asked Hermes to perform NER on a text, it will perform this tasks as saved in the skill.
Even though, agentic coding systems have been around for a while, and even I did use AI chatbots (in my case ChatGPT) already in 2023 to help me write python scripts for data visualizations for my PhD thesis, I barely could find any information about how vibe coding or agentic coding systems are used in the field of digital history (as of June 2026). A few texts and projects that I did find, I will shortly present in the following. The rest will be added in the recommended reading section. Interestingly, none of these findings were published in academic journals, but rather on private websites, in public posts on social media channels such as LinkedIn or on business websites.
Marek Jancovic, Assistant Professor of Media Studies and media historian at Vrije Universiteit Amsterdam, published a blog post on LinkedIn on 20 December 2025 about how he vibe coded an app to digitize more than 21.000 archival documents for his media project. Emphasizing that he was neither a programmer nor a digital humanist, he described step by step how he, without prior in-depth coding knowledge, used different AI chatbots (mostly Microsoft’s Co-Pilot and Google’s Antigravity) to vibe code an app which digitizes, structures and tags archival multimodal documents. The app performed OCR of handwritten and typewritten documents, clustered digitized documents into different categories, then tagged the texts and extracted entities, topics, date, and language of each text.
For Jancovic, this computation process worked “surprisingly accurately” and helped him turn his large collection of archival documents into a digitally readable and structured data set. Jancovic’s blog post is especially useful for anyone who is interested in building their own OCR tool and who wants to be inspired to develop a historical research project using LLMs from the ground up. Jancovic explains in accessible language each step of his digitalization pipeline and elaborates on obstacles and pitfalls he encountered during his process, while remaining (mostly) critical of each individual step. The only critical aspect I was missing were some thoughts on the sensitivity of his archival data, what role GDPR laws play in his case and whether utilizing big tech LLMs is problematic or not.
Another interesting dive into the use of “vibe coding” in the field of digital history I found on Stevan Lubar’s personal website. Lubar is Professor Emeritus in the departments of history and American studies at Brown University. On his website, Lubar published a blog post named “Vibe-coding for local history“ on 20 February 2026. He presents seven different projects that I would locate into the fields of public history and digital history. He vibe-coded all seven projects using the agentic coding system Claude Code by the US-American based company Anthropic. While he emphasizes that these projects should be seen as ‘proof of concepts’ of how vibe-coding can be used for the field of (digital) local history, rather than as fully-developed projects, his list of different project ideas is pretty impressive to look at (even though, Lubar does not provide detailed information or a critical reflections about the project processes yet). One project, for instance, was an interactive web map of historic sites in the coastal town Little Compton in the US-American state of Rhode Island:
A second interesting project by Lubar is a website that let’s the visitor talk to a historic character from 19th century Little Compton. Lubar fed the content of a diary from the abolitionist and feminist Sarah Soule Wilbour into Claude Code asking it to create an AI chatbot based on her content.
The loudest and most critical voice on vibe coding and digital history that I could find, belongs to Christopher Pollin. The digital humanist and historian together with his colleague, Christian Steiner, founded the company Digital Humanities Craft (DH Craft), a business that “provides solutions for research-driven IT services” in the digital humanities sector and for cultural heritage institutions. On their website, DH Craft showcases plenty elaborated projects in the field of digital history (and digital humanities) that have been conducted in cooperation with a variety of universities, research centres and cultural institutions. In a blog post on vibe-coding Pollin explains how frequently he uses “vibe-coding” for his work. This frequent use has led to a critical reflection with its practice. Pollin, who defines vibe coding as “the practice to produce code through natural language instructions and more or less accepting the output without checking” (Pollin 2025), argues that vibe coding may be useful for “throwaway projects” but does not uphold the standards of producing academic tools. Instead he proposes to formalize vibe-coding into a method for building academic tools, that he terms ‘promptotyping’.
This formal method contains four phases of an “iterative Context-Engineering workflow”: Preparation, Exploration & Mapping, Destillation and Implementation. Without going into too much detail (see full blog post here): At the core of this method is the idea that the “critical expert” is kept “in the loop”. So instead of vibe coding a project, and going back and forth with an LLM to find the right solution without keeping track of the progress, changes and of what the LLM is actually doing, Pollin proposes to feed the LLM markdown documents, he terms “promptotyping-documents”.
These documents follow the objective structure of WHAT (What is the research questions? What is the goal of the tool?) USING WHAT (What are the sources and what is its structure?) and HOW (which programming tools should be used? How should the user interface look like?). Using markdown allows for a structured approach and according to Pollin, a limited context window, that actually works better for LLMs. The expert, so the researcher, as part of the Preparation as well as Exploration & Mapping phases, identifies, defines and collects all necessary information that they then feed into the markdown files (Destillation phase). This allows the expert to be the main driver of the project, while the actual coding is performed by the LLM. The LLM is instructed to follow the instructions in the files (Implementation phase). If changes need to be made, they can be updated in the files, which are thereby made transparent.
Pollin’s approach definitely provides structure to the otherwise rather convoluted process of vibe coding. It provides oversight and agency to the expert, and makes the practice of vibe coding transparent and reproducible for other researchers. Instead of looking at vibe coded projects in the field of digital history as closed containers, we can actually follow the reasoning behind the project from the perspective of the expert as well as from the position of the LLM. However, implementing this method will also require at least a basic understanding of programming languages, code structures, and libraries from the expert, in order to navigate and accurately address potential obstacles, for example. Pollin touches here onto something that was also addressed by Paul Taylor, professor of health informatics at UCL, in a blog post from May 2026. Taylor explained how he and his colleagues who teach programming have “the fervent hope […] that the effective use of AI requires an understanding of how to write code in the traditional way.”
Hermes Agent: Digital History Projects
My recent experimenting with Hermes touches on some aspects Pollin suggests for a more formal approach of vibe coding for academic tools: the capability of tracking and checking the code that has been produced. As mentioned earlier, Hermes is an AI agent that keeps a memory and can save projects as new skills that can be used in the future. For example, I asked Hermes to create an NER visualizer of my NER data set that I collected within another project. After some back and forth, Hermes and I both came up with a more or less satisfying solution. This process was noted down in Hermes background MEMORY.md file and was flagged as an automated skill. The next time, I opened Hermes and asked it to perform NER on another data base, it ran that specific skill again, this time with all modifications attached to it. In this regard, Hermes’ ability to remember and reproduce skills on the data sets is a benefit, since gets rid of the redundance to ask an agent to implement the same modifications again.
I will give you an more detailed example: Let us imagine you are planning to create an interactive map that shows historic sites of a city. You ask Hermes the first time to create this map based on a data set of names of historic site you have. However, when the agent gives you its first result, you notice that the different dots on the interactive map are all shown in the same colour even though they represent different categories of historic sites, for instance, some are buildings and others are public spaces. You now decided to note down everything you want to change for this map and tell it to Hermes. These modifications will be saved and remembered for the next time you ask Hermes to create an interactive map for another data base. Sure, other issues might come up, especially when another kind of data set is the basis for the new map. But ‘small issues’ such as the colour scheme will not be one of them because Hermes focuses on remembering the environment constraints.
This memory feature is especially useful at the beginning of a research process when your only goal is to test different strategies to approach a research question; or when you want to get a quick idea of a specific digitized data set. However, despite Hermes’ memory feature, that allows the user to gain insights into how it processed the query and fulfilled the project objective, the agent remains the main orchestrator of the whole process. When it completes a task, it reflects on its own execution, extracts the lessons learned and writes them down in its background files. This stands in contrast to what Pollin suggests, where the “critical expert”, so the researcher, has full oversight over the project and navigates modifications via the markdown files. I believe that a combination of both, Hermes and “promptotyping”, could be an interesting path to explore in another tutorial.
Mini projects
For my experimenting with Hermes I wanted to understand what kind of solutions the agent would come up given simple prompts, without a lot of context, detail or any other sort of oversight.
Mini Project 1: Interactive NER Visualizer
My first project was the visualization of a named-entity-recognition (NER) data set that was collected as part of another project for another tutorial. The main instruction to Hermes was to visualize the tagged entities (Person, Organizations and Locations) in different ways. To start this project I opened Hermes on my terminal and instructed it to find the .csv file with the NER output in my files and create an interactive visualization. The result of the prompt was as simple as the prompt itself. These visualization could have been created without an LLM with any excel-kind software. You can find the full results here. While the visualizations were rather underwhelming, Hermes did execute this task by itself. Which means it searched my files for the NER output file from this specific project and it wrote a html script to visualize the data.
Mini Project 2: Interactive NER Visualizer & Tagger 2.0
Following the simple creation of visuals from the NER data set, I was keen to create something more elaborate. Therefore, I decided to create another NER visualizer. This time, I was more specific about the details of the tool’s features. For example, I instructed Hermes to show the original text source that is being tagged with the entities highlighted, having a table of all tagged entities on the side, differentiating between modern and historic entities (for example, Ukraine and Soviet Ukraine), showcasing entities on a historic timeline, and so on.
The result, after going back and forth a few times, can be found in the following series of images. Unfortunately, they were not as promising as I hoped for. This was mostly due to the structure of the tool, where you have to upload the document you want to get tagged and your connected model (in my case DeepSeek V4 Flash) will run the NER tagging process and display it on the website. However, since models are not deterministic, the results will look different every time you run the file. Therefore, in the image below you can see that the location “Ukraine” was supposedly tagged 67 seven times in this article. However, it actually occurred 71 times. You can also see in the list on the left-hand side the word “Ukrainian” is listed under locations, which is obviously not accurate. Another mistake is that some entities were not even tagged, such as “Europe” or “European States”.
In retrospect, I know that issues of non-determinism could have been prevented by asking Hermes to reduce the temperature of the model to 0 by implementing a system prompt into the code, giving the models a structure and clear instruction of how to perform the NER process. Obviously, the choice of model also plays a role.
While the results after providing Hermes with simple instructions to build an NER tagger are not satisfying, they offer a lot of potential. It allowed me to test visual concepts and structural ideas in minutes. I now do understand what kind of visualizations work, and which one would not. For example, the historic timeline is an interesting idea to display which historic period was mostly in the focus of the article. However, is a scatter-plot-based timeline the best choice? I am not convinced. How do you represent, for instance, organizations that lasted more than one century, and how do you show this in a timeline with dots? Also, the y-axis of the historical timeline does not serve a purpose, which seems like a waste. So, utilizing an agent to create a visualization for you, allows you to reflect on a deeper level which features of a tool are feasible and which require more thinking.
Mini Project 3: “Data Humanist” Visualization
Following the use case of the NER visualizer, I was curious about how Hermes would perform creating visualizations that are not meant to be created solely by machines. During my PhD, I studied Giorgia Lupi’s “data humanism” approach. I still follow her work as a researcher and am trying to keep up with her projects. Naturally, I was keen to see what an “omnipresent” agent would make of the instruction to create a visualization that is based on the premise that a human needs to collect and visualize the data. Thereby putting the “human” into a visualization. As the NER data was extracted and collected using digital tools, it does, in theory, not qualify for a data humanist representation. However, I was just curious to see how an AI agent would interpret a “data humanist” approach. My prompt was “Create a data visualization for the NER data set based on Giorgia Lupi’s “data humanism” approach.” Even though the result was, as expected, rather simple and underwhelming, Hermes did create a visualization that moved a little bit beyond a typical bar chart or scatter plot.
The agent divided the NER data from the .csv file into five different categories. While the entities persons and organizations remained, it split the entity locations into three sub-categories: Historical States & Empires, The Contested Present, and Wider Region. From the visualization it is unclear how the agent came up with this categorization. Asking Hermes, it replied (I asked Hermes specifically again while writing this tutorial and it remembered that we had a discussion about it the first time it created the visualization):
Hermes interpreted the content of the article according to the arguments brought forward by the author. Without a disclaimer highlighting this, such an approach can create “false facts.” This is especially true in this case, given that the article was written by Vladimir Putin in July 2021, a year before Russia’s full-scale invasion of Ukraine in February 2022, which has led to an ongoing war. For example, the problem with the category “Contested Presents” is that Hermes reproduced Putin’s arguments directed at Ukraine, which claimed that Ukrainian territories were “contested” and not sovereign due to a shared history. This is one of the main distorted arguments brought forward by Putin to justify the invasion of Ukraine.
Apart from the misleading categorization of locations, the visualization is also difficult to read, especially without annotations. While you can hover over individual “bubbles” to see how many times an entity occurs in the article, there is no explanation for why the bubbles are arranged in this specific layout. Furthermore, the visualization lacks a temporal layer, which is a critical requirement for historical data visualization. Usually, one goal of a “data humanist” approach to visualizations is to make the data more accessible for humans to read and interpret. This is not the case in this visualization as it raises more questions than it answers. Nevertheless, I believe that the initial idea of this visualization, which is reflected in its title, to showcase the geography of a text, can be an interesting starting point for further development.
takeaways
Given my own experience with vibe coding, in the recent weeks, I have seen the magic of how a quick idea in your head can turn into reality by typing a few prompts into a command line. Taking a closer look however, I have come to the conclusion that working with this specific agent (Hermes) has its own ups and downs. Here are a few takeaways:
- Hermes’ memory feature truly helps to reduce redundant mistakes when producing multiple versions of a digital history tool; Hermes’ does also remember conversations you had with it or projects you did in the past, even if you cannot find the files any longer; however, what is also will do is, remember “mistakes” you have not noticed previously
- Hermes does not only code for you but can also help you create research environments; for instance, for this tutorial, Hermes opened a new repository on my GitHub and stored two of my mini projects on Github pages, without me having to open GitHub once
- even vibe coding with an agent does not reduce the necessary oversight from the user; a structured input, as Pollin suggested, for the agent might be more sufficient in the context of building digital tools for academic purposes
- the excitement and the acceleration of building digital tools with agents such as Hermes for historical research can blur the need for academic standards; it is important to remain critical of the output
- Hermes is especially useful at the beginning of your research journey, when you want to test what research paths are worth to explore further and which are too convoluted; for instance by using samples from (multimodal) historical data and quickly creating digital tools to see if an idea can be turned into reality or not
For me personally, agentic vibe coding with agents such as Hermes are a true game changer for digital history workflows. I believe that they enable anyone to start experimenting with their (historical) (text) sources. This can be done locally, so with a fully private model, with a commercial but very cheap model, such as DeepSeek V4 Flash, or if financial resources are not a problem, with larger, faster and more advanced models from Claude or other big tech players. Jancovic’s project is a great example of how empowering these new generative AI tools can be for historians.
Obviously, the development of any digital history tool requires individual critical reflection. We must take into account questions of data privacy regarding sensitive sources; the environmental impact of our use of LLMs; critically reflect on how AI-generated code shapes a tool’s features and, consequently, the (hi)stories we produce and tell through these tools; and consider how our projects can remain reproducible given the probabilistic nature of LLMs. Nevertheless, I am excited to try out how Hermes will perform in building digital history tools with structured input. This will be discussed in another tutorial.
Reading Recommendations
Cameron Blevins, Bottlenecks, Side Quests, and the Calculus of Historical Research, 27 March 2026.
Cameron Blevins, Generative AI and History in 2025, 19 December 2025.
Jo Guldi and Jim Clifford, Building a Publication Ecosystem for Computational History, 29 June 2026.