Meet Agent: Geeklog’s First Secret Agent That Speaks to LLMs

Something new has quietly appeared in the Geeklog ecosystem.

It does not publish articles.
It does not replace your theme.
It does not manage users.
And it does not try to become another AI chatbot.

Its job is much more discreet.

Agent is a new Geeklog plugin designed to help your website communicate directly with AI systems, LLMs and future machine clients.

In other words, Geeklog now has its own secret agent.

And this agent speaks the language of AI.

Why websites increasingly need an AI-readable layer

For more than twenty years, websites have primarily been designed for two audiences:

• humans reading pages in a browser;
• search engines crawling HTML.

That model is beginning to change.

AI assistants and autonomous agents are becoming a third type of visitor.

Systems such as ChatGPT, Claude, Gemini and many other current and future AI tools increasingly need to discover, understand and retrieve information directly from websites.

Of course, an AI can try to interpret ordinary HTML.

But HTML pages were primarily designed for browsers. They contain navigation, menus, advertising, JavaScript, layout elements, widgets and many other things that are not actually part of the information an AI is looking for.

Agent provides another route.

It exposes Geeklog content in formats that machines can understand much more easily.

The idea behind Agent

Agent does not replace Geeklog.

It sits beside Geeklog and translates what the CMS already knows into a machine-friendly representation.

The architecture remains deliberately simple:

Geeklog content
      ↓
   Agent
      ↓
LLMs / AI agents / machine clients

The original article, Static Page or plugin remains the authoritative source.

Agent simply provides another representation of that content.

This distinction is important.

We do not want every plugin to implement its own ChatGPT integration, Claude integration, Gemini API or proprietary AI protocol.

Instead, Geeklog can provide a neutral machine-access layer.

Then different AI clients can decide how they want to consume it.

The first door: llms.txt

One of Agent's most visible features is support for:

/llms.txt

Think of llms.txt as a small guide placed at the entrance of the website for AI systems.

It can tell a machine:

This is what this website is about.
These are some important or recent resources.
Here is where you can retrieve cleaner versions of them.

Agent generates this file dynamically from the active Geeklog site.

There is no hard-coded hostname registry and no need to maintain separate text files manually for every installation.

This is especially important for Geeklog multisite installations, where the same plugin files may serve several websites while each site keeps its own identity and content.

Clean Markdown for LLMs

Agent can also expose an individual Geeklog resource as Markdown.

For example, instead of asking an AI system to parse a complete HTML article, Agent can provide a much cleaner representation containing:

• the title;
• canonical URL;
• content type;
• publication and modification dates;
• meta description;
• headings;
• paragraphs;
• lists;
• links;
• the actual editorial content.

Advertising scripts, theme elements and unrelated HTML are removed.

For an LLM, this is a considerably cleaner document to read and reason about.

Structured JSON for agents and applications

Humans often prefer Markdown.

Software often prefers JSON.

Agent therefore exposes the same normalized Geeklog resource model as JSON.

A machine can discover resources through a collection and retrieve individual documents with fields such as:

id
type
provider
title
canonical_url
excerpt
created
modified
visibility
capabilities
content

The important point is that this model is provider-neutral.

An AI client should not need to understand the internal gl_stories table or the Static Pages database schema.

It asks Agent for a resource.

Agent asks Geeklog and its plugins.

The content owner remains responsible for its own data and permissions.

Agent can describe its own capabilities

There is another important concept.

An intelligent client should not have to guess what a website can do.

Agent therefore exposes capability discovery.

A client can discover that a Geeklog site currently supports capabilities such as:

content.read
content.collection

and representations such as:

Markdown
JSON
llms.txt

Future Geeklog plugins will be able to expose additional capabilities through shared Geeklog contracts.

The objective is not to create an Agent-specific API inside every plugin.

Quite the opposite.

Agent should reuse the Geeklog Plugin API wherever possible.

A website can now announce its AI version

Agent also helps machines arriving directly on an ordinary HTML page.

When an Article or Static Page is displayed, Agent can add discovery information to the HTML.

For example:

<link rel="describedby"
      href="https://example.com/llms.txt"
      type="text/plain">

An article can additionally announce its machine-friendly Markdown representation:

<link rel="alternate"
      type="text/markdown"
      href="https://example.com/agent/resource.php?provider=stories&id=my-article">

This creates a very interesting bridge.

A machine arriving through an ordinary link can discover that the website offers a cleaner representation specifically suitable for automated consumption.

Why this matters to every website owner

Search visibility has always depended partly on making content understandable to machines.

First, that meant search-engine crawlers.

Now a second transformation is beginning.

People increasingly ask an AI assistant a question instead of manually visiting ten search results.

That creates a new challenge for publishers:

Can an AI easily discover what your website knows?

More importantly:

Can it understand which information actually belongs to you and retrieve a clean authoritative version of it?

Agent is Geeklog's answer to that problem.

Installing an AI-readable layer does not guarantee that ChatGPT, Claude, Gemini or any other service will cite your website.

No plugin can promise that.

But a website owner can make the site considerably easier for current and future machine consumers to discover and understand.

That is increasingly becoming part of good publishing infrastructure.

Why this matters to Geeklog administrators

For administrators, the opportunity is even larger.

Geeklog already contains decades of structured content.

Articles, Static Pages, forums, documents, videos, maps, media galleries and many other plugins often contain extremely valuable information.

The problem is not that Geeklog lacks content.

The problem is that modern AI systems do not necessarily know how to access all of this content efficiently.

Agent can become the common translation layer.

Today it already understands Articles and Static Pages.

The architecture is designed so that future providers can expose content from plugins such as:

Videos
Documents
Maps
MediaGallery
Forum
Store

without teaching every external AI client how every Geeklog plugin works internally.

Agent and Hub: two different jobs

Another new Geeklog project, Hub, focuses on relationships between content.

The distinction is intentional:

Hub   = context and relationships
Agent = machine access

Hub may eventually know that an article belongs to a pillar page, that several documents are related, or that changing one resource affects several others.

Agent can then expose that context to machine clients.

But Agent must not recreate Hub's relationship graph.

The two plugins have different responsibilities.

This separation should keep the architecture understandable and reusable.

Public and read-only by design

The first Agent generation is intentionally conservative.

Its public interface is read-only.

It is designed to help machines:

• discover;
• read;
• retrieve;
• understand.

It does not silently give AI systems permission to modify Geeklog.

Resources, capabilities and actions are deliberately treated as different concepts.

That distinction will become increasingly important as AI agents become capable of performing actions on websites.

Compatible with old and new Geeklog installations

One of the objectives of the project is particularly important for the Geeklog community.

Agent is being developed for:

Geeklog 2.1.1 → Geeklog 2.2.2
PHP 5.6 → PHP 8.3

The same modernization effort that has been taking place across many Geeklog plugins is therefore being applied here as well.

The compatibility matrix is automatically tested through GitHub Actions.

This means Agent is not being designed only for a hypothetical future Geeklog installation.

It can also help existing Geeklog websites expose years of valuable archived content to a new generation of machine consumers.

Every site owner should start thinking about AI visitors

A website administrator may reasonably ask:

Why should I install something like Agent if my site already works perfectly?

Because a site that works perfectly for humans and Google is not necessarily optimized for the way AI systems consume information.

The web is gaining another audience.

An AI visitor does not care about your theme, your sidebar or your JavaScript carousel.

It wants to know:

• what information exists;
• where the authoritative source is;
• how it can retrieve it;
• what format is available;
• what it is allowed to do.

That is exactly the conversation Agent is beginning to make possible.

For a site owner, the principle is therefore simple:

Do not wait for every AI platform to invent a different way of understanding your website. Give your website a neutral machine-readable voice.

Where is this secret agent hiding?

Every good secret agent needs a secret address.

Agent has one too:

https://github.com/Geeklog-Plugins/agent

That repository is where the plugin can be followed, inspected, tested and improved.

The project is open, and contributions, testing and feedback from the Geeklog community are welcome.

The objective is not to create a black box.

Quite the opposite.

Agent should remain a transparent bridge between Geeklog content and the rapidly evolving ecosystem of AI agents and LLMs.

The secret agent has only just started talking

Agent is still young.

Search, caching, broader plugin providers, richer Hub context and additional interoperability work can come later.

But the essential communication channel now exists.

A Geeklog website can already say:

Here is my llms.txt.

Here are my resources.

Here is the Markdown version.

Here is the JSON version.

Here are the capabilities I currently expose.

That may sound like a small technical change.

It is not.

For many years, websites learned how to speak the language of search engines.

The next generation of websites will also need to speak the language of AI.

And now Geeklog has an Agent for that.

Its secret address is:

https://github.com/Geeklog-Plugins/agent

Quietly working in the background.

Exactly where a good secret agent belongs.