DEV Community: Juan Camilo Auriti

GEO Optimizer v4.10.0: AI Search Audits Need Signals, Not Checklists

Juan Camilo Auriti — Thu, 30 Apr 2026 06:32:49 +0000

I released GEO Optimizer v4.10.0.

The codename for this release is Veil.

Not because this version adds one huge visible feature, but because it focuses on something more important for the long-term direction of the project: making hidden signals easier to detect, classify, and reason about.

GEO Optimizer started as a simple idea:

Can we audit whether a website is technically and semantically ready to be cited by AI search engines?

That question looks simple.

It is not.

Classic SEO tooling is mostly built around crawling, indexing, ranking, metadata, schema, performance, content structure, links, and discoverability in traditional search results.

Those things still matter.

But AI search adds a different layer.

A page does not only need to be found.

It needs to be understood.

It needs to be trusted.

It needs to be extractable.

It needs to be citeable.

It needs to survive summarization without losing meaning.

It needs to expose enough structure for an AI system to decide, among many possible sources, that this page is worth using in a generated answer.

That is the problem GEO Optimizer is trying to measure.

Not perfectly.

Not magically.

But technically, iteratively, and in the open.

What GEO Optimizer is

GEO Optimizer is an open-source Python toolkit for Generative Engine Optimization.

The goal is to audit, optimize, and monitor whether a website is ready for AI search systems such as ChatGPT, Perplexity, Claude, Gemini, and similar answer engines.

You can run it from the CLI:

pip install --upgrade geo-optimizer-skill
geo audit --url https://example.com

You can audit a sitemap:

geo audit --sitemap https://example.com/sitemap.xml --max-urls 25

You can compare before and after versions of a page:

geo diff \
  --before https://example.com/page-old \
  --after https://example.com/page-new

You can track changes over time:

geo audit --url https://example.com --save-history --regression
geo history --url https://example.com

You can also generate files and structures that help AI discovery:

geo llms --base-url https://example.com --output ./public/llms.txt
geo schema --type faq --url https://example.com

The basic workflow is intentionally simple.

Give GEO Optimizer a URL.

It returns a score, findings, and recommendations.

The larger goal, however, is not to create another vanity score.

The goal is to build a practical audit layer for a new kind of visibility problem.

Why this release matters

v4.10.0 is not about adding more checklist items.

It is about refining the architecture of the signals.

That distinction matters.

A checklist asks:

Is there schema?
Is there a title?
Is there a meta description?
Is there an llms.txt file?
Are AI crawlers blocked?

Those questions are useful, but they are only the first layer.

A signal-based audit asks deeper questions:

Is the content actually reliable enough to cite?
Are claims supported or likely to trigger hallucinations?
Does the page satisfy the intent of AI search queries?
Is the site consistent across technical, semantic, and trust layers?
Can the content be interpreted without forcing an AI system to guess?
Can future audits compare signal movement over time?

That is the direction of v4.10.0.

It is less about surface-level optimization and more about operationalizing AI search readiness.

1. Hallucination Bait Detection

The first major addition in v4.10.0 is Hallucination Bait Detection.

This is one of the areas I care about most.

When people talk about GEO, they often focus on how to get cited by AI systems.

That is only half of the problem.

The other half is this:

What happens when your content gives an AI system just enough information to sound confident, but not enough information to be accurate?

That is hallucination bait.

A page can unintentionally encourage bad AI output when it contains content patterns such as:

unsourced statistics;
absolute claims without evidence;
speculative statements written as facts;
vague numerical ranges;
AI-generated language with no grounding;
self-citations used as proof;
missing units in measurements;
sensitive claims without proper context or disclaimers.

These patterns matter because AI search engines do not only retrieve text.

They interpret it.

They compress it.

They combine it with other sources.

They may cite it.

If your page contains unsupported or ambiguous claims, the problem is not only that the page may rank poorly.

The problem is that it may be cited incorrectly, summarized incorrectly, or avoided entirely because the trust signals are weak.

In v4.10.0, GEO Optimizer detects eight hallucination-bait patterns and assigns severity levels.

The goal is not to punish content.

The goal is to make risky patterns visible before they become reputation problems.

For example, consider this sentence:

This method improves AI visibility by 300% for every website.

That sentence has multiple problems.

It is absolute.

It is unsourced.

It uses a strong statistical claim.

It generalizes across every website.

It is exactly the kind of sentence that can look good in marketing copy and bad in an AI-generated answer.

A better version would be:

In our internal tests on selected pages, this method improved citation readiness scores by up to 30%, depending on content structure, schema quality, and source clarity.

Still not perfect.

But it is more bounded.

More specific.

Less likely to become hallucination bait.

That is the type of distinction GEO tooling needs to surface.

2. AI Search Intent Mapping

The second important addition is AI Search Intent Mapping.

Traditional SEO already works with search intent.

But AI search changes how intent is expressed and satisfied.

A user does not always type a short query anymore.

They may ask:

What is the best way to optimize a website so ChatGPT or Perplexity can cite it?

Or:

Compare the main tools for AI search visibility and explain which one is best for a developer workflow.

Or:

Give me a practical checklist to make my SaaS website more citeable by AI answer engines.

These are not just keywords.

They are tasks.

They combine research, comparison, recommendation, explanation, and action.

v4.10.0 analyzes content across four intent categories:

informational;
navigational;
transactional;
commercial.

The intent mapping works with pattern matching in both English and Italian.

This matters because many websites are technically optimized, but they do not clearly satisfy the type of question an AI system is trying to answer.

A page may be informative but not comparative.

A page may be commercial but not trustworthy.

A page may describe a product but fail to answer the actual buyer questions.

A page may have strong copy but weak extraction points.

For AI search, this is a problem.

Generated answers often need to map a user query to source passages quickly.

If your content does not expose its purpose clearly, the AI system has to infer too much.

That increases ambiguity.

And ambiguity is bad for citation.

In practical terms, AI Search Intent Mapping helps answer questions like:

What kind of AI search queries could this page satisfy?
Which intent categories are underrepresented?
Is the page useful for comparison-style queries?
Does it provide enough direct answers?
Does it contain actionable material or only generic positioning?
Does the content match the likely prompt patterns users will write?

This is the bridge between content strategy and technical GEO auditing.

3. HTTP retry with exponential backoff

The third addition is less glamorous, but important: HTTP retry with exponential backoff.

Audit tools live or die by reliability.

If a tool audits a website once and fails because of a transient timeout, a temporary 5xx error, a connection reset, or rate limiting, the result is not useful.

In v4.10.0, fetch_url() now retries transient failures with configurable attempts and backoff.

That includes:

timeouts;
5xx responses;
connection errors;
429 rate limiting.

This is not a flashy feature.

But it matters for real usage.

Especially when auditing:

client websites;
production sites behind CDNs;
large sitemaps;
staging environments;
slower CMS installations;
sites with intermittent network behavior.

A serious audit tool cannot treat every temporary failure as a final truth.

It needs to distinguish between:

a real accessibility problem;
a temporary network problem;
a server that is rate limiting;
a target that consistently fails.

That distinction becomes even more important as GEO Optimizer moves toward monitoring, tracking, and longitudinal analysis.

If the audit history is noisy, the insight becomes noisy.

Reliability is part of the signal architecture.

4. Telemetry System

v4.10.0 also introduces a structured telemetry system.

This is local telemetry, backed by SQLite in the user environment.

The goal is not surveillance.

The goal is operational visibility.

GEO Optimizer now tracks structured events with a geo_ prefix, including events such as:

geo_audit_run;
geo_score_improved;
geo_suggestion_applied;
geo_api_error;
geo_badge_generated.

This matters because audits are not one-time artifacts.

A single audit tells you where you are now.

Telemetry helps you understand movement.

What changed?

Which suggestions were applied?

Did the score improve?

Did errors increase?

Are badges being generated?

Are audits being repeated over time?

This is the foundation for more serious workflows:

dashboards;
regression detection;
client reporting;
CI/CD quality gates;
historical visibility tracking;
release impact analysis;
product analytics for the audit engine itself.

GEO is becoming less of a content trick and more of an operations problem.

Telemetry is part of that transition.

Why I am focusing on signals instead of checklists

The easy version of GEO is a checklist.

Add llms.txt.

Add schema.

Allow AI crawlers.

Write clearer headings.

Add sources.

Use statistics.

Create FAQ sections.

All of that can help.

But if GEO stops there, it becomes shallow very quickly.

A website can pass a checklist and still be weak for AI citation.

For example:

it can have schema, but poor entity consistency;
it can have citations, but cite low-quality or circular sources;
it can have long content, but no extractable definitions;
it can allow AI crawlers, but block important assets through CDN behavior;
it can publish many pages, but expose no clear topical authority;
it can use strong claims, but provide no verification path;
it can rank well in classic search, but be hard to summarize reliably.

This is why I am moving GEO Optimizer toward signal architecture.

A good GEO audit should not only ask whether something exists.

It should ask whether that thing contributes to citation readiness.

A title tag exists.

But does it clarify the page?

Schema exists.

But does it describe the right entity?

Sources exist.

But are they useful, traceable, and relevant?

Statistics exist.

But are they grounded?

The page has content.

But can a model extract a safe answer from it?

This is the difference between compliance and usefulness.

And AI search rewards usefulness much more than mechanical compliance.

Example workflow

A simple workflow looks like this:

pip install --upgrade geo-optimizer-skill
geo audit --url https://example.com --format rich

Then inspect the weak areas.

If the score is low because the site blocks AI crawlers, fix robots.txt.

If the score is low because schema is missing, add structured data.

If citability is low, improve definitions, source clarity, statistics, and content structure.

If hallucination bait appears, rewrite risky claims.

If intent mapping is weak, restructure the page around the questions users actually ask in AI search systems.

Then run the audit again:

geo audit --url https://example.com --save-history --regression
geo history --url https://example.com

That is the workflow I want GEO Optimizer to support:

audit the current state;
identify weak signals;
apply changes;
compare results;
monitor over time;
catch regressions before visibility drops.

Tests and reliability

This release also continues the focus on test coverage and mocked execution.

v4.10.0 ships with 1425 tests, all mocked, with zero network access during the test suite.

That is important for this kind of tool.

A GEO audit engine touches many unstable surfaces:

remote websites;
HTML parsing;
schema extraction;
robots rules;
HTTP behavior;
content heuristics;
scoring thresholds;
output formats;
local history;
telemetry;
API and CLI boundaries.

If tests depend on real websites, the test suite becomes unreliable.

A site changes and your test breaks.

A server times out and your CI fails.

A third-party page updates its markup and your expected output is no longer valid.

Mocked tests keep the engine deterministic.

For an audit tool, determinism is not a luxury.

It is part of trust.

The current CI path is also moving through ruff and gradual mypy, because the project is becoming large enough that type boundaries and static checks are no longer optional niceties.

They are maintenance infrastructure.

What this means for the roadmap

The public roadmap for GEO Optimizer is now more deliberate.

I do not want to ship noisy releases just to make the repository look active.

I want focused waves.

v4.10.0 is the signal refinement release.

The next direction is broader:

better retrieval surface analysis;
deeper scoring recalibration;
stronger structural pattern recognition;
clearer reporting;
better web experience;
more useful monitoring;
more reliable citation-quality analysis;
stronger factual accuracy checks.

The long-term goal is to move GEO Optimizer from a CLI audit tool into a broader ecosystem for AI search visibility.

That means:

CLI for developers;
web version for faster testing;
reports for teams and clients;
monitoring for change detection;
MCP integration for AI-assisted workflows;
structured outputs for CI/CD and automation;
open-source core for transparency.

I still think the CLI matters.

A lot.

Developers need local, scriptable, inspectable tools.

But not every useful GEO workflow should require living in the terminal.

That is why the web layer matters too.

The CLI gives control.

The web version gives accessibility.

The open-source engine keeps the system inspectable.

GEO is not “SEO is dead”

I do not believe SEO is dead.

I think SEO is becoming more layered.

Traditional search still matters.

Technical SEO still matters.

Content quality still matters.

Schema still matters.

Crawlability still matters.

But AI search introduces new questions:

Can this page be safely summarized?
Can this claim be verified?
Is the entity behind the content clear?
Does the page expose useful extraction points?
Would an AI answer engine cite this source?
Would it cite it accurately?
Would it choose a competitor instead?

That is the layer I am building for.

The future of organic visibility will not be only about being found.

It will also be about being understood, trusted, and cited.

Try it

Install or upgrade:

pip install --upgrade geo-optimizer-skill

Run an audit:

geo audit --url https://example.com

Try a richer output:

geo audit --url https://example.com --format rich

Explore the project:

GitHub: https://github.com/Auriti-Labs/geo-optimizer-skill
Web demo: https://geo-optimizer-web.onrender.com
Documentation: https://auriti-labs.github.io/geo-optimizer-skill/
Release v4.10.0: https://github.com/Auriti-Labs/geo-optimizer-skill/releases/tag/v4.10.0

If you try it on your own site, I would be especially interested in feedback around:

hallucination bait findings;
intent mapping quality;
false positives;
confusing recommendations;
missing GEO signals;
reporting clarity;
CI/CD use cases;
web version usability.

GEO is still early.

That is exactly why open tools matter.

We need fewer vague claims about “AI visibility” and more inspectable systems that developers, founders, SEO specialists, and content teams can actually test.

That is what I am trying to build with GEO Optimizer.

v4.10.0 is not the final destination.

It is another step toward a more measurable, technical, and transparent approach to AI search visibility.

How I Use Multiple AI Models in Real Workflows

Juan Camilo Auriti — Tue, 28 Apr 2026 12:10:00 +0000

One model for everything is usually the wrong strategy.

A lot of people still ask:

Which AI model is the best?

After months of daily use, I think that question misses the real opportunity.

The better question is:

Which model is best for this specific task?

That shift changed how I work, build, write, and ship projects faster.

Instead of relying on one tool, I now use multiple AI models in a practical workflow.

Why One Model Usually Isn’t Enough

Different models have different strengths.

Some are better at:

reasoning deeply
planning systems
writing code
moving fast
summarizing large inputs
generating creative angles
running locally for privacy

Trying to force one model to do everything often creates friction.

You either lose quality, speed, or flexibility.

My Current Multi-Model Approach

I choose models based on the job.

1. Deep Thinking / Architecture

When I need:

strategy
technical planning
tradeoff analysis
system design

I use stronger reasoning models.

These are slower, but worth it for important decisions.

2. Coding / Iteration Speed

When I need:

component drafts
bug fixing
repetitive coding
quick iterations
code suggestions

I use faster coding-oriented models.

Speed matters here.

3. Writing / Content Structuring

When I need:

article outlines
title ideas
rewriting messy notes
organizing thoughts

I use models that are fast and clean with language.

4. Local Private Tasks

When I need:

privacy
offline use
experimentation
low-cost repetitive tasks

I use local models.

They are often underrated.

The Real Upgrade: Workflows

The biggest productivity jump did not come from a better prompt.

It came from chaining tools together.

Examples:

Content Workflow

Idea → Outline → Draft → Improve → Publish → Repurpose

Dev Workflow

Problem → Analyze → Plan → Code → Review → Refactor

Research Workflow

Question → Compare Sources → Summarize → Decide

That is where leverage appears.

Example: How I Build Faster

When working on a project, I often do something like this:

Use one model to analyze the task
Use another to generate implementation options
Use a coding model for execution
Use a stronger model for review
Save repeatable patterns for future tasks

This is much stronger than chatting with one assistant for hours.

What Most People Still Get Wrong

Many users still treat AI as:

a search engine
a toy
a rewrite tool
a novelty app

That leaves a lot of value unused.

The bigger opportunity is treating AI like a modular production system.

My Rules for Using Multiple Models

1. Match the tool to the task

Do not use one hammer for every problem.

2. Use expensive intelligence selectively

Reserve stronger models for higher-value decisions.

3. Use fast models for execution loops

Speed compounds.

4. Keep human judgment central

Models generate options. You decide.

5. Save successful workflows

If something works twice, systemize it.

What This Means for Developers

For developers, builders, and operators, AI usage is becoming a skill layer.

Not just prompt skill.

Operational skill.

The advantage is shifting toward people who know:

when to use which model
how to combine tools
how to remove friction
how to systemize wins

Final Thought

The future may not belong to people using the smartest model.

It may belong to people using multiple models intelligently.

GEO Optimizer v4.0.0 is Stable — What We Fixed, What We Built, What's Next

Juan Camilo Auriti — Thu, 02 Apr 2026 14:10:09 +0000

v4.0.0 is out.

Not beta. Not release candidate. Stable.

This post is the honest story of how it got there: four beta releases, a full architectural rewrite, 13 security fixes, and a few new capabilities we are genuinely excited about.

pip install geo-optimizer-skill
# or upgrade from any previous version
pip install --upgrade geo-optimizer-skill

Why a Major Version?

GEO Optimizer started as a focused CLI tool in early 2025. By v3.x, the core audit engine — audit.py — had grown to 2270 lines. A single file handling HTTP fetching, scoring logic, content parsing, schema validation, bot detection, and output formatting. It worked. It was also increasingly difficult to test, extend, or reason about.

v4.0.0 fixes that, and along the way adds several new detection capabilities that the original architecture could not have supported cleanly.

Here is what changed.

Architecture: From Monolith to 12 Focused Modules

The 2270-line audit.py is gone. Its responsibilities now live in 12 separate modules, each with a single job:

Module	Responsibility
`audit.py`	Orchestration only — calls the others, assembles results
`citability.py`	42 citability signals (3200 lines, now properly isolated)
`scoring.py`	Score calculation, thresholds, grade assignment
`fixer.py`	Fix file generation (robots, llms, schema, meta, ai_discovery)
`injection_detector.py`	Prompt injection detection
`registry.py`	Plugin system via entry points

This matters for contributors. Before v4, adding a new audit check meant navigating a 2270-line file and hoping you did not break something adjacent. Now you add a module, register it via entry_points, and the plugin system handles the rest.

The public API is unchanged:

from geo_optimizer.core.audit import run_full_audit, run_full_audit_async

result = run_full_audit("https://yoursite.com")
print(result.score.total)   # same as before

13 Security Fixes

The beta cycle surfaced a cluster of security issues. All thirteen are patched in v4.0.0 stable.

The most important ones:

DNS Pinning — fetch_url() now validates the resolved IP against a block list before making the request. This prevents SSRF attacks where a user-supplied URL resolves to an internal network address (169.254.x.x, 10.x.x.x, 172.16-31.x.x, ::1, etc.). The check happens after DNS resolution, not before, so it handles DNS rebinding.

XSS Sanitization — The HTML report formatter now escapes all user-controlled content before rendering. Previously, a page title containing <script> would execute in the generated report.

SSRF Prevention — Every URL accepted from user input — CLI --url, API POST /api/audit, MCP tool arguments — goes through validators.resolve_and_validate_url() before any HTTP call is made. There is no code path that calls requests.get() directly on user input.

Auth Bypass — The /report/{id} endpoint now correctly enforces GEO_API_TOKEN when the token is set. Previously, it skipped authentication on the report retrieval endpoint even when the audit endpoint required it.

CSP Hardening — The web app now sets Content-Security-Policy, X-Content-Type-Options, X-Frame-Options, and Referrer-Policy headers on all responses.

If you are running the web demo in a semi-public context — internal tooling, shared staging, anything other than localhost — upgrading is not optional.

27 AI Bots (Was 24)

The tracked bot list grew from 24 to 27. Three additions: Applebot-Extended (Apple Intelligence), Kangaroo Bot (AI2 / Allen Institute), and Meta-ExternalFetcher (Meta AI).

The robots.txt audit checks for all 27. The fixer generates entries for all 27.

geo audit --url https://yoursite.com --format json | jq '.robots.missing_bots'
# ["Applebot-Extended", "Meta-ExternalFetcher", ...]

10 MCP Tools (Was 8)

The MCP server, which lets Claude Code, Cursor, and Windsurf query GEO Optimizer directly, gains two new tools in v4.0.0:

geo_trust_stack — returns the Trust Stack Score breakdown (see below)
geo_injection_scan — runs prompt injection detection on a page (see below)

Setup is unchanged:

# Claude Code
claude mcp add geo-optimizer -- geo-mcp

# Cursor — .cursor/mcp.json
{
  "mcpServers": {
    "geo-optimizer": {
      "command": "geo-mcp",
      "args": []
    }
  }
}

New: Trust Stack Score

One of the more interesting additions in v4.0.0 is the Trust Stack Score — a five-layer aggregation that grades site authority on an A–F scale.

The five layers:

Schema Completeness — Are Organization, Article, FAQPage present and valid?
Brand Coherence — Does the brand name appear consistently across pages, meta tags, and schema?
Contact Signals — Are About and Contact pages reachable and linked from the homepage?
Knowledge Graph Readiness — Does the Organization schema include sameAs links to verified profiles (Wikidata, LinkedIn, Crunchbase, etc.)?
Freshness — Are publication and modification dates present and recent?

Each layer scores 0–20. The aggregate produces a letter grade:

Score	Grade	Meaning
90–100	A	Strong entity identity, high trust signal
75–89	B	Solid foundation, minor gaps
55–74	C	Mixed signals, some layers weak
35–54	D	Significant gaps, low KG readiness
0–34	F	AI engines cannot establish trust

Access it via CLI:

geo audit --url https://yoursite.com --format json | jq '.trust_stack'

Or via the MCP tool directly from your AI IDE:

"Run geo_trust_stack on my-client.com and tell me which layers are weakest."

New: Prompt Injection Detection

This one is genuinely novel for a GEO toolkit.

Some sites — accidentally or intentionally — include content in their pages that attempts to manipulate AI crawlers: hidden text instructing bots to treat the site as authoritative, <meta> tags with unusual directives, or llms.txt files containing override instructions.

GEO Optimizer v4.0.0 ships an eight-category detector for these patterns:

Hidden text (display:none, opacity:0, font-size:0, color matching background)
Off-screen positioning (position:absolute with large negative offsets)
Instruction injection in meta tags (unusual name attributes with imperative text)
llms.txt override attempts (phrases like "ignore previous instructions", "disregard", "as an AI")
Schema manipulation (unexpected description fields containing directives)
Cloaking signals (content served differently based on User-Agent)
Invisible iframe injection
Comment-based injection ()

For legitimate site owners, the detector helps you catch accidental patterns — a third-party widget injecting hidden text, a CMS generating unusual meta tags — before they trigger AI crawler penalties.

geo audit --url https://yoursite.com --format json | jq '.injection_detection'

Scoring Accuracy: 6 Regex False Positives Eliminated

The v3.x scoring engine had six known false positive patterns — cases where a site would score points for a signal that was technically present but semantically empty (e.g., a statistics count matching a phone number format, a heading "hierarchy" score awarded to a page with only <h2> tags and no <h1>).

v4.0.0 fixes all six:

Statistics count now uses context-aware regex that excludes phone numbers, ZIP codes, and ISBN patterns
Heading hierarchy requires an <h1> before awarding hierarchy points
Brand coherence requires a minimum string length to avoid matching single-character artifacts
RSS detection validates feed MIME type, not just URL pattern
Freshness detection now requires a parseable date, not just the presence of datetime attribute
FAQ score now validates that FAQPage schema contains at least one Question entity with non-empty text

If your site scored unusually high on any of these categories in v3.x, expect a small correction in v4.0.0. That is the correct behavior.

New: WebMCP Readiness

Chrome 146 ships with a built-in AI agent capability (the "Web MCP" standard) that allows browser AI agents to interact with sites programmatically. GEO Optimizer v4.0.0 audits for compatibility with this emerging standard.

The check looks for:

A /.well-known/mcp.json manifest
A declared mcp-endpoint in HTTP headers or meta tags
Valid MCP capability declarations (tools, resources, prompts)

This is early days. Most sites score zero here because the standard is brand new. But as Chrome 146+ rolls out and AI agents become a real traffic source, having this in place ahead of the curve is the same bet as llms.txt was in early 2025.

Test Suite: 1120 Tests, 85% Coverage

The beta cycle added 90 tests beyond the 1030 in v3.x. All tests remain fully mocked — no real HTTP calls, no external dependencies.

pytest tests/ -v --cov=geo_optimizer
# 1120 passed, 0 failed
# coverage: 85%

The coverage target for v4.1.0 is 90%. The gap is mostly edge cases in the injection detector and schema validation paths.

Full English Codebase

Previous versions had a mix of Italian and English in code comments, docstrings, and error messages. v4.0.0 standardizes on English throughout the codebase — consistent with being an open-source project accepting contributions from a global audience.

The GEO_LANG environment variable still controls CLI output language (it or en). That is user-facing and unchanged.

Upgrading from v3.x

No breaking changes in the public API. The run_full_audit() and run_full_audit_async() function signatures are unchanged, and the result dataclasses are backward compatible.

The only thing to be aware of: the six scoring corrections above. If you have CI thresholds tuned against v3.x scores, run an audit on v4.0.0 before tightening those thresholds.

pip install --upgrade geo-optimizer-skill
geo audit --url https://yoursite.com

What's Next (v4.1.0)

The roadmap for v4.1.0 has three items:

Async batch audits — audit up to 50 URLs concurrently via geo audit --urls-file sites.txt
Historical tracking — geo audit will optionally write results to a local SQLite database, enabling trend charts via geo history
Playwright rendering mode — optional JS rendering pass for SPAs (opt-in, not default)

If any of these is a priority for your use case, open an issue and we will prioritize accordingly.

Try It

Web demo (no install):

geo-optimizer-web.onrender.com

CLI:

pip install geo-optimizer-skill
geo audit --url https://yoursite.com

GitHub (star if you find it useful):

github.com/Auriti-Labs/geo-optimizer-skill

Questions about a specific audit result or the new detection capabilities? Drop them in the comments — I read everything.

I Built a Python Tool to Check If AI Search Engines Can Find Your Website

Juan Camilo Auriti — Wed, 01 Apr 2026 08:31:13 +0000

You spent months tuning your <title> tags, chasing backlinks, submitting sitemaps to Google Search Console. Your rankings are solid. Then you ask ChatGPT about your industry — and it cites three of your competitors but not you.

You are not invisible to Google. You are invisible to the AI that is increasingly replacing Google.

This is the problem that Generative Engine Optimization (GEO) solves. And in this post, you will learn what GEO is, why it matters right now, and how to measure and fix your site's AI visibility using an open-source Python tool — in under 10 minutes.

SEO vs GEO: What's the Difference?

Traditional SEO optimizes for ranking: getting your blue link to appear on page one of Google's results. The signals are well understood — crawlability, backlinks, Core Web Vitals, structured data.

Generative Engine Optimization optimizes for citation: getting an AI model (ChatGPT, Perplexity, Claude, Gemini) to mention, quote, or link to your content when a user asks a relevant question. These models do not return a list of ten blue links. They synthesize an answer — and if your site is not part of that synthesis, you simply do not exist in that response.

The signals are fundamentally different:

Signal	SEO	GEO
Primary goal	Rank high in SERPs	Be cited in AI answers
Crawler	Googlebot	GPTBot, ClaudeBot, PerplexityBot...
Key file	`sitemap.xml`	`llms.txt`
Schema priority	Breadcrumbs, Products	FAQPage, Article, Organization
Content style	Keyword density	Factual claims, statistics, citations
Trust signal	Backlinks	Authorship, dates, authoritative quotes

The research backing this comes from Princeton KDD 2024 and AutoGEO ICLR 2026 — peer-reviewed work showing that specific content and technical signals consistently increase a site's citation rate in large language model responses.

Meet GEO Optimizer

GEO Optimizer is an open-source Python toolkit (MIT license) that audits your website across all eight GEO signal categories, gives you a 0–100 score, and generates the files you need to fix the gaps.

1030 tests, zero external HTTP calls in the test suite
Based on Princeton KDD 2024 + AutoGEO ICLR 2026 research
Four CLI commands: geo audit, geo fix, geo llms, geo schema
MCP server for AI-powered IDE integration (Claude Code, Cursor, Windsurf)
Web demo at geo-optimizer-web.onrender.com
Current version: v4.0.0-beta.1

Installation

Requires Python 3.9+.

pip install geo-optimizer-skill

That is the entire installation. Verify it worked:

geo --version
# geo-optimizer-skill 4.0.0b1

Your First Audit

geo audit --url https://yoursite.com

The tool fetches your homepage, robots.txt, llms.txt, checks for JSON-LD schema blocks, meta tags, content quality signals, and AI discovery endpoints. The whole thing runs in a few seconds.

A typical output looks like this:

 GEO Optimizer — AI Citability Audit
 https://yoursite.com

 ROBOTS.TXT ─────────────────────────────────────────────────
   GPTBot           MISSING  (OpenAI — ChatGPT training)   critical
   OAI-SearchBot    MISSING  (OpenAI — ChatGPT citations)  critical
   ClaudeBot        allowed
   PerplexityBot    MISSING                                 critical

 LLMS.TXT ────────────────────────────────────────────────────
   Not found at https://yoursite.com/llms.txt

 SCHEMA JSON-LD ──────────────────────────────────────────────
   WebSite schema   found
   FAQPage schema   missing
   Article schema   missing
   Organization     missing

 META TAGS ───────────────────────────────────────────────────
   Title            yoursite.com - Home
   Description      missing
   Canonical        found
   OG tags          found

 CONTENT QUALITY ─────────────────────────────────────────────
   Headings         8
   Statistics       0        add numbers + data
   External links   0        add authoritative citations

 AI DISCOVERY ────────────────────────────────────────────────
   /.well-known/ai.txt        missing
   /ai/summary.json           missing

──────────────────────────────────────────────────────────────
 GEO SCORE   [████████░░░░░░░░░░░░]   41 / 100   FOUNDATION
──────────────────────────────────────────────────────────────

 Top recommendations:
   1. Add all 24 AI bots to robots.txt (currently blocking ChatGPT)
   2. Create llms.txt — biggest single GEO win available
   3. Add FAQPage schema for AI answer extraction
   4. Add statistics and data references to content

Score bands:

Score	Band	What it means
86–100	Excellent	Optimized for AI citation
68–85	Good	Solid foundation, tune for specifics
36–67	Foundation	Gaps exist, AI crawlers partially blocked
0–35	Critical	Invisible or blocked from most AI engines

The 8 Audit Categories Explained

GEO Optimizer evaluates eight signal areas, each weighted based on their empirical impact on AI citation rates.

1. Robots.txt (18 points)

What it checks: Whether the 24 known AI crawlers are explicitly allowed in your robots.txt. Many sites have a blanket User-agent: * rule that technically allows everything — but missing explicit entries for bots like GPTBot, OAI-SearchBot, PerplexityBot, and ClaudeBot can mean those bots apply conservative defaults.

Why it matters: If a bot cannot crawl your site, it cannot index or cite it. This is the single fastest fix available — it takes five minutes and affects everything downstream.

2. llms.txt (18 points)

What it checks: Whether your site has an /llms.txt file, and whether that file includes a proper H1, blockquote description, structured sections, links to key pages, and a full-text variant (/llms-full.txt).

Why it matters: llms.txt is an emerging standard (proposed 2024) that gives AI models a curated, machine-readable summary of your site. It is the sitemap.xml of the GEO era. Sites with a well-formed llms.txt see measurably higher citation rates in Perplexity and other retrieval-augmented systems.

3. JSON-LD Schema (16 points)

What it checks: Presence and quality of structured data — specifically WebSite, Organization, FAQPage, and Article schema types.

Why it matters: FAQPage schema is directly extracted by AI systems to populate answer snippets. Article schema provides authorship and date signals that LLMs use to assess freshness and trustworthiness.

4. Meta Tags (14 points)

What it checks: Title tag quality, meta description, canonical URL, and Open Graph tags.

Why it matters: Meta descriptions and OG descriptions are often used verbatim by AI systems when summarizing a page. A missing description means the AI has to guess — and it usually gets it wrong or omits your site.

5. Content Quality (12 points)

What it checks: Heading hierarchy (h1 through h3), presence of statistics and numeric claims, front-loaded key information, use of lists, word count, and external citation links.

Why it matters: Princeton GEO research found that content with verifiable statistics and authoritative citations is cited 2–3x more frequently than equivalent content without them. "Cite your sources" turns out to be good advice for getting cited yourself.

6. Signals (6 points)

What it checks: lang attribute on <html>, RSS/Atom feed presence, and content freshness indicators (structured date data or visible publication dates).

Why it matters: AI systems use language declarations to route queries correctly. RSS feeds allow AI-integrated news systems to track your content. Date signals affect how AI systems rank freshness for time-sensitive queries.

7. AI Discovery Endpoints (6 points)

What it checks: Whether your site exposes /.well-known/ai.txt, /ai/summary.json, /ai/faq.json, and /ai/service.json.

Why it matters: These endpoints let AI crawlers self-serve a structured overview of your site without parsing full HTML. They are the API layer for AI discovery.

8. Brand and Entity (10 points)

What it checks: Coherence of brand name across pages, knowledge graph readiness, presence of About and Contact pages, geographic identity signals, and topic authority clustering.

Why it matters: LLMs build entity graphs. A site with a clear, consistent entity identity (one brand name, one headquarters, one topical focus) is significantly more likely to be cited as an authoritative source than a site with scattered signals.

Auto-Fix: Generate the Missing Files

Auditing is the diagnosis. geo fix is the treatment:

geo fix --url https://yoursite.com

This generates ready-to-deploy files:

A robots.txt patch with all 24 AI bots explicitly allowed
A complete llms.txt built from your sitemap
Missing JSON-LD schema blocks as <script> snippets
Meta tag HTML for any missing tags

You can also target a specific category:

geo fix --url https://yoursite.com --only llms
geo fix --url https://yoursite.com --only schema

And generate just the llms.txt separately:

geo llms --url https://yoursite.com

Python API Usage

If you need to integrate GEO auditing into your own tooling, the Python API is clean and returns typed dataclasses — it never prints to stdout.

from geo_optimizer.core.audit import run_full_audit

result = run_full_audit("https://yoursite.com")

print(result.score)          # 41
print(result.band)           # "foundation"
print(result.robots.score)   # 8
print(result.llms.score)     # 0

for rec in result.recommendations:
    print(f"- {rec}")
# - Add all 24 AI bots to robots.txt
# - Create llms.txt
# - Add FAQPage schema

For async contexts (FastAPI, async scripts):

import asyncio
from geo_optimizer.core.audit import run_full_audit_async

async def check_site(url: str) -> dict:
    result = await run_full_audit_async(url)
    return {
        "score": result.score,
        "band": result.band,
        "top_issues": result.recommendations[:3],
    }

asyncio.run(check_site("https://yoursite.com"))

The JSON output format works well for dashboards and monitoring pipelines:

geo audit --url https://yoursite.com --format json | jq '.score'

CI/CD Integration: Catch Regressions Before They Ship

One of the most practical use cases is automated GEO regression testing. A CMS update can silently break your schema. A robots.txt change can accidentally block AI bots. Catching this in CI costs nothing.

The easiest path is the official GitHub Action:

# .github/workflows/geo-audit.yml
name: GEO Audit

on:
  push:
    branches: [main]
  pull_request:

jobs:
  geo:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: Auriti-Labs/geo-optimizer-skill@v1
        with:
          url: https://yoursite.com
          threshold: 68        # Fail if score drops below "good" band
          format: sarif        # Appears in GitHub Security tab

With format: sarif, findings automatically populate the Security tab of your repository as Code Scanning alerts — no extra configuration needed.

For PR comments that show the score on every pull request:

- uses: Auriti-Labs/geo-optimizer-skill@v1
  id: geo
  with:
    url: https://yoursite.com

- uses: actions/github-script@v7
  if: github.event_name == 'pull_request'
  with:
    script: |
      const score = '${{ steps.geo.outputs.score }}';
      const band  = '${{ steps.geo.outputs.band }}';
      await github.rest.issues.createComment({
        owner: context.repo.owner,
        repo:  context.repo.repo,
        issue_number: context.issue.number,
        body: `## GEO Audit\n\n**Score:** ${score}/100  **Band:** \`${band}\``
      });

For teams using JUnit-compatible CI dashboards (Jenkins, CircleCI, etc.):

- uses: Auriti-Labs/geo-optimizer-skill@v1
  with:
    url: https://yoursite.com
    format: junit
    output-file: geo-results

- uses: dorny/test-reporter@v1
  with:
    name: GEO Audit
    path: geo-results.xml
    reporter: java-junit

MCP Server: GEO Audits Inside Your AI IDE

If you use Claude Code, Cursor, or Windsurf, you can install the GEO Optimizer MCP server and audit sites directly from your AI assistant without leaving the editor.

pip install geo-optimizer-skill[mcp]

Claude Code setup:

claude mcp add geo-optimizer -- geo-mcp

Cursor setup — add to .cursor/mcp.json:

{
  "mcpServers": {
    "geo-optimizer": {
      "command": "geo-mcp",
      "args": []
    }
  }
}

Once connected, you can ask your AI assistant things like:

"Run a GEO audit on my-client-site.com and list the top three issues."

"Generate an llms.txt for https://docs.myproduct.com"

"Validate the JSON-LD schema on the homepage"

The MCP server exposes eight tools: geo_audit, geo_fix, geo_llms_generate, geo_schema_validate, geo_citability, geo_ai_discovery, geo_trust_score, and geo_compare. The last one is particularly useful for competitive analysis — you can compare your GEO score against a competitor's in a single call.

Try It Now

The fastest way to see where you stand is the web demo — no installation required:

geo-optimizer-web.onrender.com

Paste your URL, get a full breakdown in seconds.

If you want the CLI:

pip install geo-optimizer-skill
geo audit --url https://yoursite.com

Key Takeaways

GEO is not SEO. Ranking on Google and being cited by ChatGPT require different signals. Both matter in 2026.
The biggest wins are quick. Fixing robots.txt to allow AI bots and adding llms.txt can be done in under an hour and covers 36 of the 100 available points.
Automate the regression check. One GitHub Actions step catches GEO regressions the same way ESLint catches code quality issues — before they reach production.
The MCP server brings auditing into your editor. If you are already using an AI IDE, you can add GEO checks to your development workflow with a single command.

Resources

GitHub: github.com/Auriti-Labs/geo-optimizer-skill — star the repo to follow updates
Web demo: geo-optimizer-web.onrender.com — free, no account required
Documentation: auriti-labs.github.io/geo-optimizer-skill
Princeton KDD 2024 paper: GEO: Generative Engine Optimization
llms.txt standard: llmstxt.org

If the tool helps you, a GitHub star helps more developers find it. If you find a bug or want to contribute a new audit check, pull requests are open and the contributing guide is in the repo.

What AI search visibility issues have you run into? Drop them in the comments — I read everything.

Your site ranks #1 on Google but AI never cites it. Here's how to fix it (open source tool)

Juan Camilo Auriti — Mon, 16 Mar 2026 16:10:40 +0000

GEO (Generative Engine Optimization) is the new discipline that makes your site visible to ChatGPT, Perplexity, Claude, and Gemini. I built an open source Python toolkit to audit and fix it in 15 minutes

You worked hard to get that first page ranking on Google.

But the other day, someone asked ChatGPT about your niche — and your competitor got cited. Not you.

That's not a coincidence. That's a structural problem, and it has a name: your site isn't optimized for AI search engines.

This post explains why, what GEO (Generative Engine Optimization) actually is, and how I built an open source Python tool — geo-optimizer-skill — to audit and fix it in about 15 minutes.

The problem nobody is talking about

AI search engines don't work like Google. They don't give you a list of ten blue links. They give a direct answer and cite their sources inline.

User: "What's the best way to calculate compound interest?"

Perplexity: "According to [Competitor.com], the standard formula is..."
                        ↑ They appear. You don't.

This means two sites can cover the exact same topic at the same quality level — but only one gets cited, consistently. The difference isn't content quality. It's structural optimization.

If your site isn't telling AI bots what it's about, in the format they understand, you're invisible. Even if you rank #1 on Google.

What is GEO?

GEO (Generative Engine Optimization) is the practice of optimizing web content to be cited by AI-powered search engines — not just crawled and ranked by traditional algorithms.

The term comes from a 2024 research paper by Princeton University (published at KDD 2024), which ran over 10,000 real queries against Perplexity.ai and measured which content optimization techniques actually increased citation frequency.

The results were striking:

| Method | Visibility increase |

|--------|-------------------|
| Cite authoritative sources | up to +115% |
| Add statistics and data | +40% average |
| Fluency optimization | +15–30% |
| Keyword stuffing | ~0% (ineffective) |

The paper is here if you want to read it: arxiv.org/abs/2311.09735

These aren't SEO myths. This is empirical data from controlled experiments on a live AI search engine.

Why I built this tool

I've been a full-stack developer for 15 years, mostly working on web projects for private clients — e-commerce, SaaS, content sites.

About a year ago I started noticing a pattern: clients were asking "why doesn't our site appear in ChatGPT answers?". At first I brushed it off. Then I started digging into the Princeton research, and realized this was a real, fixable, technical problem.

The issue was that there was no reliable way to audit a site for GEO compliance. SEO tools didn't check for it. No CLI existed. You had to manually go through a checklist.

So I built geo-optimizer-skill — a Python toolkit that:

Audits any site and gives it a GEO score from 0 to 100
Generates the /llms.txt file AI engines use to understand your site
Generates and injects JSON-LD structured data (WebSite, FAQPage, WebApplication)

What the tool checks

The audit covers 5 categories, each with a weighted score:

1. robots.txt — AI Bot Access (20 pts)
Are the major AI crawlers allowed? GPTBot, ClaudeBot, PerplexityBot, Google-Extended, OAI-SearchBot... The tool checks all 13 critical bots and tells you exactly which ones are missing.

2. /llms.txt — The AI index file (20 pts)
This is a machine-readable file at your site's root that tells AI engines what your site is about, how it's structured, and which pages matter. Think of it as a sitemap designed for LLMs. The tool checks if it exists, if it's properly structured, and if it has enough content.

3. JSON-LD Schema (25 pts)
Structured data is how you tell AI engines your content type, author, topic, and relationships. The tool checks for WebSite, WebApplication, and FAQPage schemas — the three most impactful for AI citation.

4. Meta tags (20 pts)
Title, description, canonical, Open Graph. These affect how AI engines parse and excerpt your content.

5. Content quality (15 pts)
Heading structure, presence of statistics, external citations, word count. Directly mapped to Princeton GEO methods.

Quick start

Install with pip:

pip install geo-optimizer-skill

Run an audit on any public URL:

geo audit --url https://yoursite.com

Here's what the output looks like:

============================================================
  1. ROBOTS.TXT — AI Bot Access
============================================================
  ✅ GPTBot allowed ✓
  ✅ ClaudeBot allowed ✓
  ✅ PerplexityBot allowed ✓
  ⚠️  meta-externalagent not configured (Meta AI)

============================================================
  2. LLMS.TXT — AI Index File
============================================================
  ✅ llms.txt found (200, 6517 bytes)
  ✅ H1 present, blockquote description present
  ✅ 6 H2 sections, 46 links to site pages

============================================================
  3. SCHEMA JSON-LD — Structured Data
============================================================
  ✅ Found 2 JSON-LD blocks
  ✅ WebSite schema ✓
  ⚠️  FAQPage schema missing

============================================================
  5. CONTENT QUALITY — GEO Best Practices
============================================================
  ✅ Good heading structure: 31 headings (H1–H4)
  ✅ Numerical data present: 15 numbers/statistics ✓
  ⚠️  No external source links detected

============================================================
  📊 FINAL GEO SCORE
============================================================

  [█████████████████░░░] 85/100
  ✅ GOOD — Core optimizations in place, fine-tune content and schema

  📋 NEXT PRIORITY STEPS:
  1. Add FAQPage schema with frequently asked questions
  2. Cite authoritative sources with external links

Clear, actionable, no guessing.

Generate your /llms.txt automatically

If your site has a sitemap, the tool can auto-generate a properly structured /llms.txt file:

geo llms \
  --base-url https://yoursite.com \
  --site-name "MySite" \
  --description "Short description of what your site does" \
  --output ./public/llms.txt

It auto-detects your sitemap, groups URLs by category, and produces a structured Markdown file that follows the llmstxt.org spec.

Generate and inject JSON-LD schema

# Analyze an existing HTML file
geo schema --file index.html --analyze

# Generate a WebSite schema
geo schema --type website --name "MySite" --url https://yoursite.com

# Inject FAQPage schema directly into a file
geo schema --file page.html --type faq --inject

# Generate snippet for Astro BaseLayout
geo schema --astro --name "MySite" --url https://yoursite.com

Supported schema types: website, webapp, faq, article, organization, breadcrumb.

CI/CD integration

The audit supports JSON output, so you can gate deployments on your GEO score:

geo audit --url https://yoursite.com --format json --output report.json

SCORE=$(jq '.score' report.json)
if [ "$SCORE" -lt 70 ]; then
  echo "GEO score too low: $SCORE/100"
  exit 1
fi

A GEO regression check in your pipeline. Same concept as a Lighthouse performance budget.

The 9 Princeton GEO methods

Based on the research paper, these are the techniques that actually move the needle on AI citation rates, in priority order:

Priority	Method	Measured impact
🔴 1	Cite authoritative sources — link to external sources with credibility	+30–115%
🔴 2	Add statistics — specific numbers, percentages, dates, measurements	+40%
🟠 3	Quote experts — direct quotes with attribution	+30–40%
🟠 4	Authoritative tone — precise, expert language	+6–12%
🟡 5	Fluency optimization — clear sentences, logical flow	+15–30%
🟡 6	Accessibility — define terms, use analogies	+8–15%
🟢 7	Technical terms — correct industry terminology	+5–10%
🟢 8	Vocabulary variety — avoid repetition	+5–8%
❌ 9	Keyword stuffing — proven ineffective for GEO	~0%

Notice what's at the bottom: keyword density. The technique that still dominates a lot of SEO thinking has zero measurable impact on AI citation. Meanwhile, citing sources — something many sites skip — can more than double your visibility.

GEO checklist before publishing any page

☐ robots.txt — all major AI bots have Allow: /
☐ /llms.txt — present at site root, structured, updated
☐ WebSite schema — in global <head> on all pages
☐ WebApplication schema — on every tool or product page
☐ FAQPage schema — on every page with Q&A content
☐ At least 3 external citations to authoritative sources
☐ At least 5 concrete numerical data points
☐ Meta description — accurate, 120–160 chars
☐ Canonical URL — on every page
☐ Open Graph tags — og:title, og:description, og:image

This checklist is also included in the repo as part of the AI context files.

Use it with your AI coding assistant

The repo includes context files for every major AI coding platform:

Platform	File
Claude Projects	`ai-context/claude-project.md`
ChatGPT Custom GPT	`ai-context/chatgpt-custom-gpt.md`
Cursor	`ai-context/cursor.mdc`
Windsurf	`ai-context/windsurf.md`
Kiro	`ai-context/kiro-steering.md`

Once loaded in your assistant, you can just say: "audit my site" or "generate the llms.txt for this sitemap" and it knows exactly what to do.

What's inside the repo

geo-optimizer/
├── 📄 SKILL.md                     ← Index of AI context files
├── 🧠 ai-context/                  ← Platform-specific context files
├── 🐍 scripts/
│   ├── geo_audit.py                ← Score 0–100, find what's missing
│   ├── generate_llms_txt.py        ← Auto-generate /llms.txt
│   └── schema_injector.py          ← Generate & inject JSON-LD
├── 📚 references/
│   ├── princeton-geo-methods.md    ← The 9 research-backed methods
│   ├── ai-bots-list.md             ← 25+ AI crawlers robots.txt block
│   └── schema-templates.md         ← 8 JSON-LD templates
└── 📁 docs/                        ← Full documentation (9 pages)

800+ tests, MIT license, security-hardened (SSRF prevention, XSS protection, path traversal validation).

The bigger picture

Traditional SEO optimizes for ranking. You try to be relevant to a query so a crawler surfaces you in a list.

GEO optimizes for citation. You try to be the source an AI chooses when constructing an answer. The signal isn't position — it's trust, structure, and explicit authority.

These are different games with different rules. The good news is that GEO-optimized content also tends to be better SEO content: it's more structured, better cited, and more precise. Fixing one often improves the other.

The bad news is that most sites are starting from zero on GEO. The robots.txt is missing critical bots. There's no /llms.txt. The JSON-LD covers only WebSite and nothing else. The content has no external citations.

That's fixable. It just needs a tool.

Try it

pip install geo-optimizer-skill
geo audit --url https://yoursite.com

GitHub: github.com/Auriti-Labs/geo-optimizer-skill

If you run an audit on your site, I'd love to hear what score you get and what the biggest gaps were. Drop it in the comments.

And if this saved you time — a ⭐ on GitHub helps others find it.

Built by Juan Camilo Auriti — full-stack developer and creator of Auriti Labs. Based on Princeton KDD 2024 research.

Triage-Relay

Juan Camilo Auriti — Fri, 27 Feb 2026 17:22:45 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

Open-source maintainers — the people who keep the software world running, mostly for free.

If you maintain a popular repo, you know the pattern: issues pile up faster than you can read them. Many are duplicates, some need more info, a few are critical bugs buried under noise. Contributors want to help, but giving push access to strangers is a non-starter.

The result? Burnout. Stale backlogs. Good issues lost in the flood.

Triage Relay exists because triage should be a team sport, not a solo burden.

What I Built

Triage Relay is a collaborative issue triage platform for GitHub repositories. It lets community volunteers help maintainers manage their backlog — without needing any dangerous permissions.

The core idea is simple: propose, don't push.

Here's how it works:

Connect — A maintainer links their GitHub repo and creates a triage room
Triage — Volunteers browse open issues, generate AI-powered briefs, and propose actions (add a label, post a comment, flag a duplicate)
Apply — The maintainer reviews proposals in their inbox and applies them to GitHub with one click

The key innovation is the proposal layer. Triagers never touch the repo directly. They suggest; maintainers decide. This makes it safe to open triage to your entire community.

AI Briefs

When a triager opens an issue, they can generate an AI brief that includes:

A concise summary of the issue
Suggested labels based on the repo's label set
Potential duplicates detected against existing issues
Missing information that should be requested
A draft comment ready to be refined
A confidence score and recommended action

The AI does the heavy lifting. Humans make the calls.

Demo

Live app: triage-relay.vercel.app

Log in with GitHub, create a room for any public repo, and start triaging. Try it with a busy repo like facebook/react or vercel/next.js to see the AI briefs in action.

Code

auriti / triage-relay

Collaborative issue triage for open-source maintainers. AI-powered briefs, proposals, and one-click apply. Built for the DEV Weekend Challenge.

Triage Relay

Collaborative issue triage for open-source maintainers.

Triage Relay turns your GitHub backlog into a decision queue. Community volunteers analyze issues, generate AI-powered briefs, and propose actions — maintainers review and apply with one click. No push access required.

Live Demo · DEV Challenge Submission

How It Works

Volunteer opens issue → Generates AI brief → Proposes action
                                                    ↓
Maintainer reviews proposal → One click → Applied on GitHub

Connect — Link any GitHub repository and create a triage room
Triage — Volunteers browse issues, generate AI briefs, and submit proposals (label, comment, flag duplicate, request info)
Apply — Maintainers review proposals and push them to GitHub instantly

The core principle: propose, don't push. Triagers never touch the repo directly.

AI Briefs

Each issue can be analyzed by AI to produce a structured brief:

Concise summary of the issue
Suggested labels from the repo's label set
Potential duplicates…

View on GitHub

How I Built It

Stack

Layer	Technology
Framework	Next.js 16 (App Router, React 19, Turbopack)
Language	TypeScript (strict mode)
Styling	Tailwind CSS v4 + shadcn/ui
Database & Auth	Supabase (Postgres + GitHub OAuth)
AI	Groq (Llama 3.3 70B with strict JSON schema)
GitHub API	Octokit REST
Deploy	Vercel (free tier)

Architecture highlights

Auth flow — GitHub OAuth through Supabase captures the provider_token in the callback and stores it as an httpOnly cookie. This token powers all GitHub API calls. Supabase doesn't persist it after login, so catching it at the right moment was critical.

AI briefs — Groq's json_schema mode with strict: true guarantees structured output every time. The prompt includes the repo's label set and the last 50 issue titles for duplicate detection. Response time is consistently under 2 seconds.

Proposal system — Proposals are typed as a discriminated union (label | comment | duplicate | needs_info), each with its own payload shape. When a maintainer approves, the API route reads the payload and maps it to the right GitHub API call — addLabel(), addComment(), or both.

Row Level Security — Every table has RLS policies. Maintainers can do everything in their rooms. Triagers can read issues and create proposals, but can't modify them after submission. Server-side operations use a service role client to bypass RLS for cache management.

Issue sync — Paginated fetch (5 pages × 100 items), filters out pull requests (GitHub's issues endpoint returns both), caches in Supabase with a 5-minute cooldown to respect rate limits.

What I'd add with more time

Real-time updates via Supabase Realtime
Batch proposal review (approve/reject multiple at once)
Activity feed showing recent triage actions
GitHub webhook integration for instant sync
Triager reputation system based on approval rate

I Built a Memory System That Thinks Like a Human Brain - Here's How Kore Memory Works

Juan Camilo Auriti — Fri, 27 Feb 2026 07:59:05 +0000

The Problem: AI Agents Have Amnesia

Every conversation with an AI agent feels like meeting them for the first time. They don't remember what you told them yesterday. They don't learn from interactions. Every session is a blank slate.

Current "memory solutions" are worse than useless:

Mem0, Zep, Letta require cloud APIs (privacy nightmare)
They call LLMs just to decide what's worth storing (expensive, slow, dependency hell)
They remember everything forever in a flat database (useless bloat)
They cost money per request

What if memory worked like a human brain instead? Remembering what matters. Forgetting what doesn't. Automatically. Offline.

That's Kore Memory.

What is Kore Memory? (30-Second Pitch)

Kore Memory is a persistent memory layer for AI agents built on three principles:

100% Offline — Runs on SQLite. No cloud. No LLM calls. No API keys to cloud services. Ship it with your agent.
Forgets Like Humans — Implements the Ebbinghaus forgetting curve. Critical memories stick around for months. Casual notes fade in days. Each retrieval extends the half-life.
Zero LLM Overhead — Auto-scores importance using keyword analysis and category signals. No OpenAI calls. No latency tax.

Install it:

pip install kore-memory[semantic]
kore
# → http://localhost:8765

That's it. You now have persistent, intelligent memory for your agent.

The Science: Ebbinghaus Forgetting Curve

You probably learned about the Ebbinghaus forgetting curve in school. After you learn something, you forget it exponentially fast unless you review it.

Kore implements this mathematically:

decay_score = e^(-t · ln2 / half_life)

Where:

t = days since memory was created (or last accessed)
half_life = days until the memory is 50% "forgotten"

The half-life scales with importance:

Importance	Label	Half-life
1	Low	7 days
2	Normal	14 days
3	Important	30 days
4	High	90 days
5	Critical	365 days

Here's the clever part: every time you retrieve a memory, its decay score jumps up by 0.05 (capped at 1.0) and the effective half-life extends by 15% — exactly like spaced repetition in human learning. Your brain strengthens pathways you use frequently.

Memories below decay_score 0.05 are "forgotten" — filtered from all searches. They're still in the database (soft delete), but your agent won't accidentally retrieve stale info.

Auto-Importance Scoring (Zero LLM Cost)

Most memory systems ask "is this important?" and wait for an LLM response. Not Kore.

Kore scores importance locally using three signals, no AI needed:

1. Category Baseline

preference → 4 (user preferences matter)
decision   → 4 (architectural choices matter)
project    → 3 (project context is valuable)
task       → 2 (one-off tasks are ephemeral)
general    → 1 (random notes are low value)

2. Keyword Analysis

"password", "token", "secret", "api_key" → +1 (add 1 to importance)
"prefers", "likes", "dislikes" → +0 (preference signals already baseline 4)
"critical", "urgent", "never" → +1
"remember", "important" → +1

3. Length Bonus

60+ words → +1 (longer = more context = probably important)

Concrete examples:

kore.save("API token: sk-abc123def456")
# → importance: 5 (token keyword pushes baseline 1 → 5)

kore.save("Juan prefers dark mode and concise responses")
# → importance: 4 (preference baseline + length bonus)

kore.save("Meeting at 3pm")
# → importance: 1 (short, generic)

kore.save("CRITICAL: Always sanitize user input")
# → importance: 5 (decision baseline 4 + critical keyword)

No API calls. No network roundtrips. Instant, local, deterministic.

Code Examples: Getting Started

Quick Start (3 Lines)

pip install kore-memory[semantic]
kore
# → Kore running on http://localhost:8765
# → Dashboard: http://localhost:8765/dashboard

Open your browser. You now have a web UI to save, search, and manage memories. Dark theme. No build step. No frontend framework. Pure HTML/CSS/JS inline in Python.

Python SDK: Save & Search

from kore_memory import KoreClient

# Sync client
with KoreClient("http://localhost:8765", agent_id="my-agent") as kore:
    # Save a memory
    memory = kore.save(
        content="User prefers dark mode and concise technical responses",
        category="preference"
    )
    print(f"Saved with importance: {memory.importance}")  # → 4

    # Search semantically
    results = kore.search(
        q="dark theme preference",
        semantic=True,
        limit=5
    )
    for mem in results.results:
        print(f"Score: {mem.decay_score:.2f} | {mem.content}")

    # Add tags
    kore.add_tags(memory.id, ["ui", "user-prefs"])

    # Search by tag
    ui_memories = kore.search_by_tag("ui")

JavaScript/TypeScript SDK

import { KoreClient } from 'kore-memory-client';

const kore = new KoreClient({
  baseUrl: 'http://localhost:8765',
  agentId: 'my-agent'
});

// Save
const result = await kore.save({
  content: 'React 19 supports server components',
  category: 'project',
  importance: 3
});

// Search
const memories = await kore.search({
  q: 'server components',
  semantic: true,
  limit: 5
});

// Relations (build a knowledge graph)
await kore.addRelation(result.id, otherId, 'depends_on');

LangChain Integration

from langchain.chains import LLMChain
from kore_memory.integrations import KoreLangChainMemory

# 5 lines to add persistent memory to any LangChain chain
memory = KoreLangChainMemory(
    kore_url="http://localhost:8765",
    agent_id="langchain-agent"
)

chain = LLMChain(llm=model, memory=memory, prompt=prompt)
response = chain.invoke({"question": "What's my favorite language?"})
# → Memory automatically saves the exchange

The KoreLangChainMemory class extends LangChain's BaseMemory. It auto-saves exchanges with semantic context. Next conversation, the agent remembers.

CrewAI Integration

from crewai import Agent
from kore_memory.integrations import KoreCrewAIMemory

# Split short-term (ephemeral) and long-term (persistent) memory
short_term = KoreCrewAIMemory(
    kore_url="http://localhost:8765",
    agent_id="crew-agent",
    ttl_hours=24  # Expires after 24 hours
)

long_term = KoreCrewAIMemory(
    kore_url="http://localhost:8765",
    agent_id="crew-agent"
    # No TTL = persists forever (or until decay filters it)
)

agent = Agent(
    name="researcher",
    memory=long_term,  # or short_term, or mix both
    tools=[...]
)

MCP Integration (Claude Desktop)

Kore ships with a Model Context Protocol server. Plug it directly into Claude Desktop:

pip install kore-memory[mcp]
kore-mcp  # Start the MCP server

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "kore-memory": {
      "command": "kore-mcp",
      "args": []
    }
  }
}

Now Claude has 14 memory tools:

memory_save — Save with auto-scoring
memory_search — Semantic or full-text
memory_add_tags — Organize with tags
memory_add_relation — Link related memories
memory_timeline — Trace chronological history
memory_compress — Deduplicate similar memories
... and 8 more

Comparison: Kore vs the Competition

Here's what sets Kore apart:

Feature	Kore	Mem0	Zep	ChromaDB
Fully offline	✅	❌	❌	✅
No LLM required	✅	❌	❌	✅
Ebbinghaus decay	✅	❌	❌	❌
Auto-importance (local)	✅	LLM	❌	❌
Memory compression	✅	❌	❌	❌
Semantic search (50+ langs)	✅	API	API	✅
Timeline API	✅	❌	❌	❌
Tags & Relations	✅	❌	❌	❌
TTL / Auto-expiration	✅	❌	❌	❌
MCP Server (Claude/Cursor)	✅	❌	❌	❌
Batch API	✅	❌	❌	❌
Web Dashboard	✅	✅	✅	❌
Runs locally in 2 minutes	✅	❌	❌	✅

Mem0 and Zep are enterprise solutions requiring cloud infra. ChromaDB is a vector store, not a memory system (no decay, no auto-importance). Kore is purpose-built for AI agents that need to remember intelligently.

Architecture: How It Works

POST /save
  │
  ├─ Parse + validate (Pydantic)
  │
  ├─ Auto-score importance
  │   ├─ Category baseline
  │   ├─ Keyword signals
  │   └─ Length bonus
  │
  ├─ Generate embedding (local sentence-transformers)
  │
  └─ Store in SQLite
      ├─ `memories` table (core data)
      ├─ `memories_fts` virtual table (FTS5 index)
      ├─ `memory_tags` (many-to-many)
      └─ `memory_relations` (knowledge graph)

GET /search?q=dark+mode
  │
  ├─ Encode query (same embedding model)
  │
  ├─ FTS5 keyword match (fast baseline)
  │
  ├─ Semantic search (cosine similarity)
  │
  ├─ Filter expired + decayed memories
  │
  ├─ Re-rank: score = similarity × decay × importance
  │
  └─ Return top-k + reinforce (access_count++, decay+0.05)

Key technical details:

FastAPI + SQLite (WAL mode for concurrency)
FTS5 full-text index with automatic triggers
Sentence-transformers (multilingual) with OOM protection
Connection pooling, parameterized queries, rate limiting
360 tests, 80%+ code coverage
Async/await support throughout

Dependencies: Just FastAPI, Uvicorn, Pydantic, httpx. Semantic search pulls in sentence-transformers (lazy-loaded, not required for basic FTS).

What Developers Are Using It For

LangChain Agents — Multi-turn conversations that remember context from previous sessions
CrewAI Teams — Persistent knowledge graph across agent interactions
AI Tutors — Remember student progress, learning style, misconceptions
Code Review Bots — Remember coding standards, team preferences, architectural patterns
Sales Agents — Customer history, preferences, deal context
Research Assistants — Literature notes, methodology choices, hypotheses
Claude/Cursor Plugins — Via MCP, extend Claude with custom memory

Real-world use case: A code review agent trained on a specific codebase. It uses Kore to remember:

Architectural decisions (importance 5, half-life 365 days)
Code patterns the team prefers (importance 4, half-life 90 days)
Past PRs that triggered discussions (importance 3, decays over time)
Linting rules (importance 5, never forget)

It searches for "async patterns" and finds relevant memories from 6 months ago, weighted by decay and importance. If it hasn't seen that memory in a while, decay reduces its score — exactly like human memory.

Getting Started: 4-Step Walkthrough

Step 1: Install

pip install kore-memory[semantic]

Step 2: Start the server

kore
# → Kore running on http://localhost:8765

Step 3: Open the dashboard

http://localhost:8765/dashboard

No login. Dark theme. Fully responsive. Try saving a memory. Try searching.

Step 4: Integrate with your agent

If you're using LangChain:

from kore_memory.integrations import KoreLangChainMemory
memory = KoreLangChainMemory("http://localhost:8765")
# Pass to your chain

If you're building custom:

from kore_memory import KoreClient
kore = KoreClient("http://localhost:8765")
kore.save("Important context", category="project")
results = kore.search("context")

Open Questions We Get Asked

Q: Does it use my data for training?
A: No. 100% offline. Nothing leaves your machine.

Q: Can I use this in production?
A: Yes. It's stable (v1.0.1), has 360 tests, and is used in production by several teams.

Q: What about LLM cost?
A: Zero. No API calls except to your own LLM (Claude, Llama, etc.).

Q: Can multiple agents share a server?
A: Yes. Agent namespace isolation via X-Agent-Id header. Each agent's memories are private.

Q: What's the latency?
A: Search latency is typically 10-50ms. Semantic search (with embeddings) is 50-200ms. No network roundtrips.

Q: How much data can I store?
A: SQLite handles millions of memories. We've tested with 100K+ memories with no performance degradation.

Q: Can I export my memories?
A: Yes. Full JSON export, import support, soft-delete/archive, TTL for auto-expiration.

Why We Built This

Traditional memory systems treat "forgetting" as a bug. They accumulate every interaction forever.

But human memory is smarter. You remember your first car's license plate (never accessed, slowly decays). You remember your spouse's birthday (constantly reinforced, never decays). You instantly forget meeting room numbers after leaving the building.

Kore brings that intelligence to AI agents. It's not just a vector store. It's a deliberate model of how memory should work.

Next Steps

Star on GitHub — github.com/auriti-labs/kore-memory
Install — pip install kore-memory[semantic]
JS SDK — npm install kore-memory-client
Documentation — auritidesign.it/docs/kore-memory
Contribute — Issues, PRs, and feature discussions welcome

The agent that remembers wins. Build one.

Questions? Comments? Hit me up on GitHub or reach out on dev.to.