# GEO Optimizer: a CLI that scores whether AI engines can cite your site

> Auriti Labs' geo-optimizer-skill audits a URL against 47 GEO methods, generates llms.txt and JSON-LD fixes, and queries ChatGPT and Perplexity to see if your brand is actually cited. Here is what it does, how to run it, and where it stops.

**Auriti-Labs/geo-optimizer-skill** — Open-source Answer Engine Optimization (AEO) & Generative Engine Optimization (GEO) toolkit — audit, optimize & track whether ChatGPT, Perplexity, Gemini & Google AI Overviews cite your site. AI SEO / LLM SEO. CLI, Python, MCP, Astro.

- Repository: https://github.com/Auriti-Labs/geo-optimizer-skill
- Website: https://auriti-labs.github.io/geo-optimizer-skill/
- Stars: 945 · Forks: 111
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/auriti-labs-geo-optimizer-skill

## The gap geo-optimizer-skill targets: ranking on Google while being invisible to ChatGPT

Classic SEO tooling measures crawlability, backlinks and keyword signals on a results page. geo-optimizer-skill measures something else: whether an answer engine can read, parse and quote a page when it synthesizes a response. The README frames the difference plainly, noting that AEO and GEO measure whether an engine can read, parse, understand and cite your content, and that a site can rank well on Google and still be largely opaque to AI systems.

The project is aimed at developers and automation owners rather than SEO account managers. The README's own comparison table lists the CLI's core use as a local audit engine, CI/CD integration and JSON output, with developers and automation as the target. That framing matters: the tool ships as a command line binary, a Python library, an MCP server and an Astro integration, and the repository carries an action.yml for GitHub Actions plus a Dockerfile. It is built to be called from a pipeline, not clicked through in a dashboard.

The scoring model is the substance. The README states the tool scores a site 0 to 100 across 8 categories using 47 methods, and points to two papers as the academic basis: a KDD 2024 paper and an ICLR 2026 paper. The categories named in the README are technical and structural: robots.txt bot permissions, llms.txt presence and depth, JSON-LD schema richness, brand entity coherence, multi-page topical authority and content citability. Nothing here is about link building.

## How the audit works: fetch, parse, score, then generate fixes

The mechanism visible in the repository is a fetch-and-parse pipeline rather than a hosted crawler. Dependencies in pyproject.toml are requests, beautifulsoup4 and lxml, which is the shape of a tool that pulls a URL, parses the HTML and the linked resources, and evaluates them locally. The README describes the output as a score plus prioritized fixes, and lists the artifacts it can produce: robots.txt bot rules, llms.txt and JSON-LD schema.

There are 7 output formats according to the README banner, and the Dockerfile shows two of them directly in its usage comment, plain text and JSON, plus an HTML report written to a mounted volume. The repository also carries a .geo-optimizer.example.yml file, which indicates a config file path for repeatable runs, and a SCORING_RUBRIC.md at the top level, which is where the category weights would be documented.

The second half of the tool is citation tracking. The README describes geo citations as querying real answer engines with the questions your customers ask, then reporting whether your brand is mentioned and your domain is cited as a source, along with which competitors get cited instead. That is a different data flow from the audit: instead of parsing your own site, it sends prompts to engines and inspects the responses. The optional dependency groups in pyproject.toml confirm the split, with an llm extra pulling openai and anthropic, an embedding extra pulling sentence-transformers, and an mcp extra pulling the mcp package.

## Installing geo-optimizer-skill and running a first audit

The README's Quick Start leads with a zero-install path through uvx, which runs the published package without touching your environment. This is the fastest way to see whether the scoring model says anything useful about a site you own.

```bash
uvx --from geo-optimizer-skill geo audit --url https://yoursite.com
```

The command takes a single --url flag and prints a score with prioritized fixes. If you want the package installed instead, pyproject.toml declares the distribution name geo-optimizer-skill and requires Python 3.9 or newer, so a standard pip install against that name is the documented route, with the CLI exposed as geo.

```bash
pip install geo-optimizer-skill
geo audit --url https://yoursite.com --format json
```

The second command switches to JSON output, which is the form you would feed into a CI step or a script that diffs scores between deploys. The Dockerfile gives a third route, building an image tagged geo-optimizer and running the same subcommand with the audit arguments appended, plus an optional volume mount when you want an HTML report written to disk rather than stdout.

```bash
docker build -t geo-optimizer .
docker run geo-optimizer audit --url https://example.com --format json
```

For a first real use, audit your own domain rather than a competitor's. The per-category breakdown tells you which of the 8 areas is dragging the total down, and the fixes it emits are concrete files (robots.txt rules, llms.txt, JSON-LD) that you can diff against what your site already serves. The repository ships a .geo-optimizer.example.yml that you can copy to .geo-optimizer.yml to pin repeated runs to the same settings.

## Where the tool stops: no server-side history, and the scoring model is the project's own

The clearest limitation is stated by the project itself. The README's comparison table separates the MIT CLI from the paid GeoReady tiers, and assigns monitoring, score history, regression alerts and agency reporting to the platform, not the open-source tool. If what you want is a dashboard that tells you a score dropped last Tuesday, the CLI alone will not do it. You would have to build that loop yourself from JSON output.

A second constraint is methodological. The 47 methods and the 8 categories are the project's own construct, documented in SCORING_RUBRIC.md. The README cites external research for specific claims, such as a Semrush test reporting that JSON-LD schema lifts LLM extraction accuracy from 16% to 54%, but the composite 0 to 100 score is an aggregate the project defines. Treat it as a checklist with weights, not as a measurement with a known error bar. Two sites with the same score are not necessarily equally citable.

There is also a scope boundary worth naming. The tool evaluates technical and structural signals on pages it can fetch. If your content sits behind authentication, behind a paywall, or on a domain that blocks the fetcher, the audit has nothing to parse, and the README does not document a workaround for that case. Third, citation tracking depends on engine APIs and the optional llm extra, so that half of the tool carries API cost and rate-limit exposure that the audit half does not.

## geo-optimizer-skill versus a classic SEO crawler

The obvious alternative is an established SEO crawler such as Screaming Frog or Sitebulb, and the difference in approach is not cosmetic. A classic crawler models the Googlebot contract: it walks internal links, checks status codes, canonical tags, meta robots, sitemaps and duplicate content, and reports on indexability and on-page keyword signals. Its output is oriented toward ranking in a results page.

geo-optimizer-skill models a different consumer. It checks whether named AI bots are permitted in robots.txt, whether an llms.txt exists and how deep it goes, whether JSON-LD describes the entity well enough for extraction, and whether the brand's presence is coherent across pages. Those checks are largely absent from a traditional crawler's default rule set, because until recently there was no reason to run them. The README is explicit that these complement traditional SEO rather than replace it.

The practical consequence is that the two tools disagree on what a good page looks like. A page can pass every classic crawl with a clean canonical, fast response and tidy headings, and still score badly here for missing structured data or for blocking GPTBot. Conversely, a site with mediocre crawl hygiene can carry a strong llms.txt and rich schema. If your team already owns a crawler, the sensible split is to let the crawler own indexability and let geo-optimizer-skill own the AI-readiness layer, rather than trying to fold both into one score.

## Maintenance, upgrade cost and the MIT licence

The repository is not archived, and the last push was on 2026-09-05. Release cadence is visible in the version history: v4.16.4 on 2026-08-14, v4.17.0 on 2026-08-30, v4.17.1 on 2026-08-31, and pyproject.toml carries version 4.18.0. That is a project shipping fixes on a short cycle, with release notes that name specific work such as check-drift and schema templates in v4.17.1 and brand-name extraction and schema @graph handling in v4.16.4.

Upgrade cost is low by construction. The runtime dependency set is small and pinned to broad ranges: click 8.x, requests 2.x, beautifulsoup4 4.12 and up, lxml 4.9 to below 7.0, urllib3 1.26 to below 3.0. Everything heavier sits behind optional extras, so a plain audit install does not drag in FastAPI, WeasyPrint, sentence-transformers or the LLM SDKs. That keeps the CI footprint small, but it also means the citation-tracking features require you to opt into the llm extra and manage API keys yourself.

The licence is MIT, declared both in pyproject.toml and in the Dockerfile image labels. MIT permits commercial use, modification and redistribution, and imposes no copyleft obligation on your own code. The one thing to keep straight is the boundary the README draws: the CLI and the web audit are MIT and free, while the GeoReady platform tiers are a separate commercial product starting at $19/month according to the README's table. Using the CLI does not put you on that plan, and the README does not describe any licence obligation flowing from the CLI to the hosted service. This is a description of what the files say, not legal advice.

## Conclusion

Adopt geo-optimizer-skill if you run a content site, docs portal or marketing domain and want a repeatable, scriptable check of the structural signals AI answer engines read: robots.txt bot rules, llms.txt, JSON-LD, entity coherence. Skip it if you need continuous server-side monitoring with score history and regression alerts, since the README places that in the paid GeoReady platform, not the MIT CLI. Verify first: run geo audit against your own URL and read the per-category breakdown, then confirm that the llms.txt and schema files it proposes match what your CMS can actually emit.

## FAQ

### What is GEO optimization, and what does geo-optimizer-skill do about it?

GEO, or Generative Engine Optimization, is the practice of making a site readable and citable by AI answer engines rather than only rankable in a results page. geo-optimizer-skill scores a URL from 0 to 100 across 8 categories using 47 methods and emits concrete fixes such as robots.txt bot rules, llms.txt and JSON-LD schema.

### Is GEO replacing SEO, or does geo-optimizer-skill replace my SEO tooling?

The README states that the signals it checks complement traditional SEO rather than replace it, and that a site can rank well on Google while remaining largely opaque to AI systems. The tool covers technical AI-readiness signals such as bot permissions, llms.txt and structured data, not backlinks or keyword ranking.

### Do I still need search engine optimization if I use geo-optimizer-skill?

Yes. The project positions itself alongside SEO rather than instead of it, and the README's own framing is that AEO and GEO answer a different question from SEO: whether an engine can read, parse, understand and cite your content. Classic crawlability and ranking signals remain a separate concern.

## Sources

- [Auriti-Labs/geo-optimizer-skill on GitHub](https://github.com/Auriti-Labs/geo-optimizer-skill)
- [License: MIT](https://github.com/Auriti-Labs/geo-optimizer-skill/blob/main/LICENSE)
- [Project website](https://auriti-labs.github.io/geo-optimizer-skill/)
- [README](https://github.com/Auriti-Labs/geo-optimizer-skill/blob/main/README.md)
- [Releases](https://github.com/Auriti-Labs/geo-optimizer-skill/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/auriti-labs-geo-optimizer-skill