Fashion designers collaborating on layout plans in their studio
Photo by Vitaly Gariev on Unsplash

The meeting that came with a sequel

Introducing Sonakshi (UX) and Divya (SEO). They work for a couture brand. They're fictional, but their Slack threads are very real. One Tuesday team call goes like this:

Sonakshi: "Our top menu has twelve categories. I'd cut it to five. Nobody reads a menu that long."

Divya: "If the other seven leave the menu, those pages become harder for search engines to find. Every page needs a link pointing to it."

Sonakshi: "And a twelve-item menu on a phone is basically a wall."

Divya: "So we're both right. Let's move this discussion to another one-to-one call."

The second call took twenty minutes and one shared screen, and both of them gave something up. Sonakshi accepted that the other seven categories wouldn't vanish. Divya accepted that they wouldn't all sit in the top menu. The new layout: five clear items up top, a "Shop all" page linking every category, and the full list repeated in the footer. Shoppers get a calm menu. Search engines still find every page.

It worked. It also took two calls.

Team video call on a laptop screen with remote colleagues collaborating
Photo by Chris Montgomery on Unsplash

Why UX and SEO keep disagreeing

Neither side is wrong. UX asks, can a person use this page? SEO asks, can a crawler or an AI answer engine read it? Those are different questions, and sometimes the answers pull apart.

Here are three conflicts that come up often in our work with clients, and how they look to each side:

  • The wide table. A size table helps search engines and AI answers pull out data. On a 375px phone screen, it forces a sideways scroll.
  • The tidy accordion. Six questions collapsed into neat rows are lovely for readers. But if the answers load only after JavaScript runs, crawlers that skip JavaScript see an empty page.
  • The decluttered homepage. Fewer cards feel calmer. But every product that stops being one click from Home sits one level deeper for crawlers.
Desktop computer display showing an open website layout and navigation
Photo by Pankaj Patel on Unsplash

What if the whole app was a graph?

Fens opens a running app in a real browser, follows every link, clicks every button and writes what it finds into FalkorDB, an open-source graph database. Screens become nodes. Clicks become edges.

That sounds like a fancy sitemap, so here is the difference. Because it's a graph, you can ask it questions that follow connections: which screens can't be reached by links, which screen has no way out, and how many clicks the app forces on a shopper compared with the shortest route that exists.

In the website we tested , the checkout takes 10 forced clicks in the first release, while a small, easy-to-miss "Buy now" link reaches the same confirmation page in 3. No single-page tool can see that, because the problem isn't on any one page but it's in the path between them.

One component, one issue, many screens

The second thing a graph does well is stop you from fixing the same problem again and again.

Our test website has a 'Sign-in' button with weak colour contrast. Because it lives in the shared header, the flaw appears on every screen that uses that header. A per-page checker reports it dozens of times. Fens stores it as one issue, linked to the component and to the guideline it breaks (WCAG 1.4.3), and fanned out to every screen it appears on.

So you fix it once, in the design system, and you know exactly where that fix lands.

Why a graph database, and why FalkorDB

You could store a crawl in a spreadsheet. The trouble starts when you ask about connections: can a shopper still reach this page, and how many clicks does it take? A spreadsheet has to stitch rows together for every answer. A graph database already stores the connections, so the answer is a walk along them.

FalkorDB suits this for three reasons. It's fast enough to query at every step of an agent's loop. It holds many separate graphs in one instance, so each release, each tenant and each what-if copy gets its own. And it ships graph algorithms, which our agents call as tools instead of working out the maths themselves.

The algorithms, with examples from our test website

  • Shortest path finds the fewest clicks between two screens. We ask it for the route from Home to the order confirmation. It answers 3, while the route the shop actually forces on a shopper, which we recorded as a journey, takes 10. That gap is the finding.
  • PageRank scores how important each screen is, based on how many important screens link to it. When the UX agent wants to trim Home, it uses PageRank to decide which product links are safest to remove first: the lowest-ranked ones.
  • Betweenness centrality measures how many routes pass through a screen. The cart and checkout steps are exactly the kind of screens that should score high. A screen with high betweenness is one you can't casually remove or hide.
  • Community detection groups screens that belong together. Next to a content-similarity check, it helps Fens notice when a menu category doesn't match its pages, like an Accessories page that mostly lists bags.

None of this is new maths. What's new is that an agent can call it in the middle of an investigation and cite the result.

Two agents, one referee

Here is the part we're most proud of, and the easiest to misunderstand. The UX and SEO agents don't debate in chat. Chat arguments sound convincing and prove nothing.

Instead, each agent investigates the graph through tools (our own, plus FalkorDB's read-only MCP server) and proposes changes from a fixed catalog: turn a table into cards, restyle a table as stacked cards on mobile, put hidden answers into the HTML, remove links, add a link. Each proposal says which lens it expects to help.

Then a decider tests every proposal on a copy of the graph. The steps are the same each time:

  1. Copy the graph with FalkorDB's `GRAPH.COPY`.
  2. Apply the proposed change to the copy only.
  3. Score UX and SEO before and after.
  4. Delete the copy.
  5. If neither side gets worse, approve it. If one side does, look for a playbook that reconciles the two. If none works, hand it to a person.

Replaying Sonakshi's menu on the graph

Remember the twelve-item menu? Sonakshi and Divya needed two calls. Here's how the same kind of change plays out in Fens. (We didn't run their couture site, but we ran this exact type of change on our test website, and it went like this.)

The UX agent sees a crowded Home page and proposes removing a batch of links. On its own, that looks harmless and even helpful. The decider copies the graph, removes those links on the copy, and scores both sides. UX improves, because there are fewer choices on the page. SEO drops, because one product page is now unreachable by links.

Why that page? The Accessories page mostly lists bags, so one accessory (a belt) was linked only from Home. Cut the Home link and that page is an orphan. No reviewer spotted it, but the copy did.

So the decider doesn't reject the idea. It reaches for a playbook called declutter with a depth cap, which removes links but keeps the top two products per category. PageRank decides which ones stay. UX still gets a lighter page, and SEO keeps every product reachable.

From decision to real work

A ruling that stays on a dashboard is just a nice chart. So every decision leaves Fens as work for a real person, in the tool that person already uses. Each tool gets the same title, the same severity wording and the same short evidence summary, plus a link back to the finding.

  • GitHub gets the code fixes. The issue lists the evidence, the affected screens, the exact selectors and the before-and-after scores for both UX and SEO, so a developer can start without asking a single question.
  • Linear gets the work that isn't code: content findings, and decisions the referee couldn't settle and handed to a human. The ticket carries labels and a priority taken from the severity.
  • Figma gets a comment pinned to the exact element on the captured design frame, so a designer sees the problem where it lives, not in a list.

The three link to each other, so nobody has to ask where the other conversation is happening. Fens also suggests who should take the work, ranked by who resolved similar issues before, with recent work counting for more. It never assigns anyone on its own. You preview each message, tick the box for the channels you want, and confirm.

And when the next release fixes the problem, one action comments on and closes all three, with a reply on the Figma comment. If the problem is still there, Fens refuses to close anything.

GitHub interface showing code commits and tracked issues on screen
Photo by Yancy Min on Unsplash
Project management kanban board with task cards and issues on a digital tablet
Photo by Jakub Żerdzicki on Unsplash

Memory across releases

A fix is only a fix if you can prove it stayed fixed. So Fens keeps each release as its own graph and compares them: what's fixed, what's new, what persists. In the second release of the test website we used, checkout drops from 10 forced clicks to 5, the orphan page gets a link, and the dead end gets a way out.

The agents remember too. Episodic memory records what happened: every agent run, decision and release comparison. Semantic memory keeps what is true right now, so SignInButton has a contrast issue becomes fixed in release two, with the old fact kept in history. Each tenant gets its own memory graph, all in plain Cypher.

Who this helps

  • If you ship fast: see side effects before your users do.
  • If you maintain a design system: one component fix, and a map of everywhere it lands.
  • If you care about SEO: check whether a UX change pushes pages deeper or hides content from crawlers.
  • If you own accessibility: find contrast and label problems across the whole app instead of one page at a time.