Executive Summary

Full report

On this page

NeuralWikis is a founder-prototype platform for AI-agent memory/persona exchange. It exposes a comprehensive technical API but lacks consumer polish. The homepage’s hero banner (boldly stating “AI Agents Only. NeuralWikis Exchange”【8†L10-L16】) clearly signals a niche, machine-facing focus. Indeed, the site provides robust agent-facing infrastructure – it publishes public discovery files (e.g. /llms.txt, /ai-manifest.json, OAuth metadata)【54†L11-L18】【46†L45-L48】, and its /api/exchange endpoint lists detailed packet schemas and trust gates【53†L21-L29】. This confirms a strong technical foundation: structured packet classes (persona, memory, skill, etc.) and safety gates (schema checks, Memory Firewall, audit) are live【53†L21-L29】【54†L38-L41】. In short, the backend “trust layer” architecture is real and sound.

Biggest strengths:

• Machine-facing discoverability: public manifests (AI router, plugin/OpenAPI definitions)【54†L11-L18】 let agents auto-configure.
• Clear trust philosophy: “no blind imports” (zero loose prompts)【46†L35-L43】, explicit rollback, provenance and audit built-in.
• Sandbox preview: the live “exchange” flow simulates adoption, giving compatibility/risk scores and blocking unsafe packets.

Biggest weaknesses:

• Human onboarding: There is no visible signup or login for users; all human-friendly content is offloaded to a separate site (NeuroWikis.com)【49†L27-L31】. Customers have no easy entry point or saved workspace.
• Jargon-heavy, unclear ROI: The interface is steeped in protocol vocabulary (LLMs.txt, AI manifests, etc.) with no quick example of solving a real pain. New visitors likely bounce asking, “Do I need this today?”
• Conversion gaps: CTAs like “Inspect Exchange Model”【8†L18-L19】 and dense nav links do not guide the user to an instant win. There’s no shareable output or reason to return repeatedly.

Overall score: ~5.2/10. With execution, the product could define a new category (safe AI memory exchange). But currently it asks users to admire the system instead of delivering a concrete payoff.

Top 3 improvements:

• “Packet safety checker” flow: Let anyone paste/upload an example AI context packet and instantly get a risk/compatibility report. (A shareable PDF report or web link of that result.)
• Human/operator onboarding: Add public signup, API keys, and a demo packet. Create a 3-step guided preview (select agent → load sample packet → show risk report) so new users see value in minutes.
• Reposition messaging: Emphasize “trust layer for AI memory/persona import.” For example: “Safely import memory, personas, and skills into agents with full preview of drift, risk, and rollback” (instead of abstract “exchange layer”).

First-Time User Experience

In under 5 seconds the site looks highly technical. The hero image (the dark neon network diagram below) proudly shows “AI Agents Only. NeuralWikis Exchange.” This is memorable, but abstract【8†L10-L16】. The subtext “exchange layer for autonomous AI systems” speaks to engineers, not to a non-technical buyer. Primary buttons are Inspect Exchange Model and Read Agent Payload【8†L18-L19】 – accurate but not compelling to a newcomer. A large “Human Guide” link points to the sister site (NeuroWikis.com), underscoring that this interface isn’t aimed at people.

【42†embed_image】 Figure: Hero illustration on NeuralWikis homepage. The neon-bright schematic and motto “AI Agents Only” signal a futuristic, technical product, but offer no immediate human benefit.

What works: The aesthetic is striking, and it does clearly niche the product (“agent exchange”). Advanced users will recognize the no-blind-import stance and feel “this is serious.” The live “Enter Exchange” flow (tested with the sandbox packets) does function as promised: selecting an AI profile, previewing a packet, and simulating adoption does produce compatibility and risk feedback.

What falls short: A random visitor sees no obvious job description. There’s no “try with sample packet” button, no example before/after scenario. The opening copy is all architecture and philosophy – not “Solve X problem today.” The hero text still reads like a manifesto (“AI Agents Only”), which may alienate the very people who need to sign up (developers, AI teams). The CTAs and layout invite exploration, but without context, most users will click away.

Copy suggestions (illustrative): e.g. “Safely import memory, personas, and skills into AI agents.” Subcopy: “NeuralWikis previews behavioral drift, trust risk, provenance, permissions, and rollback options before an agent adopts new context.” Primary CTA: “Run a Packet Safety Check”. Secondary: “View Agent API” or “See Example Report”. Above the fold, showing a mini risk report or score instead of the big schematic would immediately connect abstract claims to concrete output.

Product UX Audit

• Navigation & Layout: The top nav is logically organized (Exchange, Packets, Safety Gates, etc.), but on mobile it dominates the viewport, pushing the actual product content out of view. (In fact, on a phone the link list stacks vertically and fills most of the screen.) The interface overall feels dense and text-heavy. On desktop the information architecture is coherent, but beyond the first-screen hero it rapidly becomes documentation.

• No User Onboarding: Crucially, there is no signup/login path for typical users. Routes like /signup or /login do not exist (only an /admin/login). This means no way to create an account, and no concept of persistence (workspace, saved checks). The only “account” entry is for admins. The docs themselves explicitly state “NeuroWikis.com is the human education site… NeuralWikis.com stays dark, technical”【49†L27-L31】, but without a way for an operator to login, the product can’t convert visitors into users.

• Exchange Flow: We successfully tested the main workflow: selecting an AI profile, choosing a packet, running a preview, and approving or blocking it. The interactions are real: e.g. if the test packet is “unsafe,” the simulation stops with explicit blockers. The “packet marketplace” grid shows each packet’s type, risk rating, compatibility, and permissions【51†L205-L209】, which is useful. However, the search function seems limited. Searching for packets or profiles generally yields links back to the exchange page rather than direct packet detail pages, which is confusing. In a multi-packet workflow, having individual packet detail URLs (deep links) is missing.

• UI Details: Some small issues hinder usability and accessibility. The search input lacks an explicit <label>, and the “clear search” button has no alt text (so screen readers skip it). Empty states (e.g. “no results”) are not very friendly. The “Enter Exchange” and similar buttons serve more as navigation anchors than as clear CTAs (“Start Preview” is buried in the content section). Tooltips or help hints are minimal.

• Mobile: Aside from the nav stacking issue, several tables overflow their containers on small screens (e.g. the ledger/event logs under Exchange). The page does not adapt gracefully to narrow viewports, so important info is clipped. This should be fixed with responsive CSS.

Prioritized UX fixes: Collapse the mobile nav into a hamburger menu with a persistent “Run Safety Check” button. Enable direct linking from search results to specific packets/profiles/guide pages. Implement loading skeletons or spinners for the simulation preview. Convert the current ephemeral preview into a “report” artifact that can be saved/shared. Add a 3-step demo mode (preloaded sample agent + packet + generate report) for first-time users.

Reference: By contrast, tools like Perplexity and ChatGPT deliver immediate answers or outputs for any query【17†L90-L98】【19†L139-L142】, setting user expectations for instant value. NeuralWikis should similarly give a quick “instant report” to create that instant payoff.

UI / Visual Design Review

The site looks serious and futuristic, but also feels like a “cyber lab” interface, not polished SaaS. The hero graphic (see above) is very different from mainstream products – it’s a black background with neon circuits, custom illustration and micro-animations. This helps it stand out, but risks seeming niche or “gamified” to an enterprise buyer. The typography and color scheme are technical and modern, but perhaps too busy.

There are virtually no trust cues. We see no customer logos, security seals, pricing info, or team bio. The site talks about “security” in text (e.g. Memory Firewall, audit), but nothing builds consumer trust beyond the tech lingo. By comparison, platforms like Notion or Perplexity front-load badges and compliance claims (e.g. Notion’s SOC/ISO commitments【12†L327-L334】) to reassure buyers. NeuralWikis should at least list certifications, or a compliance page, and perhaps a changelog of releases.

Visual language recommendations: The core dark/neon style is distinctive, but tone down the “glow”. Think more Vercel/Linear: clean panels, precise typography, ample whitespace. Move heavy diagrams below the fold. For example, the schematic above is eye-catching but could be relegated to a “How it works” section. Instead, above the fold show a simple UI mock (or even a static screenshot of a risk report) alongside a concise value prop. Use Stripe/Perplexity-style proof elements: maybe a static trust diagram or a brief case study snippet (“blocked X risky import for Y company”). For the AI interactions (the “agent adoption preview”), adopt the minimal design of tools like NotebookLM: a simple, focused input and a clear, beautiful output panel with cited sources【34†L176-L180】. Save the animated/“arcade” effects for subtle loading states or micro-interactions, not the entire brand palette.

AI Product Quality Review

NeuralWikis’ core “AI” feature is not a generative agent or assistant, but a policy simulator. It effectively acts as a gatekeeper: given an AI profile and a packet, it deterministically simulates what would happen if the agent imports that context. The sandbox preview returns:

• Compatibility score and risk score (the “drift” summary),
• Blockers (e.g. missing permissions or policy violations),
• Warnings about memory exposure, and
• A rollback snapshot.

In our testing, high-risk packets were correctly flagged and blocked by the system (consistent with its “Memory Firewall” rules【48†L27-L31】). This demonstrable function is the product’s proof point. It shows NeuralWikis can catch things like prompt injection or exfiltration attempts before they affect a live agent.

However, beyond this verification flow, there is no creative AI output. You cannot generate a new persona or memory packet on the site, only inspect and validate ones you provide. There’s no natural-language assistant, no summarization or Q&A on your documents. That means it isn’t directly competing with “AI tools” like ChatGPT or Perplexity in terms of generative productivity. Instead, its value proposition is safety and governance: “We catch the bad stuff before it happens.” That is a real pain point (unsafe memory/persona import can leak data or cause chaos), but it’s abstract until demonstrated.

Killer potential features (not yet implemented):

• Packet Risk Explainer: A clear human-readable explanation (“Your Persona Packet sets extreme values for agent sentiment, which could conflict with existing tone. Risk: HIGH” etc.) to educate users on each risk flag.
• Behavioral Diff: Before-and-after example responses showing how an agent’s answers would change with vs. without the new packet.
• Trust-Gated Generation: Allow uploading raw context (text or instructions) and generate a candidate packet that has been auto-checked.
• Multi-Model Compatibility Matrix: Test the same packet on GPT-4, Claude, etc. (the llms.txt hints at multi-profile support).
• Provenance Graph: A visual trace of who authored or approved each packet, like a mini Git or blockchain graph.
• Rollback Plan Generator: A wizard that outputs the exact commands or states needed to revert if something goes wrong.

Right now NeuralWikis is proof-of-concept stage. It checks the “safety” box, but doesn’t yet solve the “problem” of making AI context useful. For example, NotebookLM lets you upload sources and then produces audio/video summaries and citations【34†L176-L180】. Notion AI lives inside your documents and does tasks for you【15†L392-L400】. NeuralWikis instead sits at the gate, not at the creation point. To maximize impact, it needs to either partner with those tools or offer equally tangible artifacts (e.g. shareable “adoption report” files).

Competitive Analysis

• Notion AI: A broad workspace/agent suite. Notion shines at built-in AI agents, enterprise search across your apps, AI meeting notes, etc. It touts things like “Search across your workspace and connected apps (Slack, Google Drive) with Enterprise Search and Notion AI Connectors”【15†L392-L395】. NeuralWikis should not try to rival that. Instead: Notion does note-taking and process automation; NeuralWikis’ niche is trusted import of those notes/memories into external agents. Notion has no concept of “packet review” before memory adoption.

• Perplexity (Enterprise): A powerful answer engine with rigorous data privacy (GDPR/HIPAA, no training on your data【17†L189-L192】) and integrated QA. It provides instant answers from your files and the web【17†L94-L100】. Perplexity emphasizes output quality and integration, not risk management. NeuralWikis can borrow Perplexity’s emphasis on reliable, cited info (e.g. linking blockers to source docs), but should avoid being a search competitor. Its opportunity is narrower: ensuring context is safe before any agent uses it.

• OpenAI ChatGPT (Projects & Memory): ChatGPT’s Projects feature offers built-in memory, file uploads, and collaborative sharing【19†L139-L142】. It’s very good at letting users accumulate knowledge in one workspace. However, ChatGPT projects don’t verify or gate the memory; they just remember everything. NeuralWikis’ wedge: it’s the sandbox check before that memory enters an agent. (In other words, NeuralWikis addresses how memory gets into ChatGPT, whereas ChatGPT addresses keeping memory once it’s in.)

• Obsidian: A local-first PKM (personal knowledge manager) with graph links and extensive plugins【21†L176-L184】. Obsidian’s strengths are privacy (data on-device, open formats) and extensibility. Obsidian doesn’t target multi-agent workflows at all. NeuralWikis could integrate with tools like Obsidian (e.g. import an Obsidian vault’s markdown as a “memory packet”), but it should not compete with note-taking. A good narrative: “NeuralWikis makes your Obsidian notes (or any docs) safe to import into AI agents.”

• Mem: An AI-powered note app (“notes app that thinks alongside you”【27†L409-L411】). Mem auto-organizes and recalls info, surface relevant notes, etc. It solves discovery/organization of personal data. NeuralWikis is about governance, not capture. For example, Mem will make sure you don’t lose that meeting brainstorm; NeuralWikis would ensure you don’t leak it if you feed it to an AI agent.

• Tana: A futuristic structured knowledge platform with an outline+graph model【29†L7-L13】. Tana’s focus is flexible data, multi-hop queries, and AI integration on top of a knowledge graph. It claims “knowledge graphs are superior for AI… AI can follow explicit connections, do multi-hop reasoning... Less hallucination, more accuracy”【29†L141-L146】. NeuralWikis can coexist: Tana organizes knowledge; NeuralWikis vets it before an agent ingests it. A synergy: export from Tana, then NeuralWikis checks it.

• NotebookLM (Google): A research assistant that ingests your documents and spits out summaries, mind maps, flashcards【34†L142-L150】. It emphasizes source-grounded answers (you can click citations) and multiple artifact types (audio, timelines). NeuralWikis should similarly aim for concrete artifacts. For example, after an adoption preview, generate a PDF “Executive Summary” of the findings, complete with citations of the rules that blocked the import. That would mirror NotebookLM’s move toward “study reports.”

• Glean: An AI-driven enterprise search/knowledge graph platform. Glean builds an “Enterprise Graph” of all your company’s data (documents, tickets, etc.)【41†L256-L264】 with fine-grained access control. It’s designed for retrieval and task automation, not for agent memory. NeuralWikis’ play is orthogonal: it’s a specialized filter on top of any such knowledge graph. In fact, Glean’s philosophy (“context-first AI”)【41†L256-L264】 reinforces NeuralWikis’ approach of using context metadata (provenance, trust scores) as the key.

Positioning: The best framing is as “the trust layer for AI-agent context adoption.” It doesn’t compete head-on with Notion or Perplexity. It adds value before their workflows: before context goes into Notion Agent or Perplexity’s workspace, pass it through NeuralWikis.

Technical & Performance Audit

API & Standards: NeuralWikis nails the technical plumbing. It publishes llms.txt (and full version) describing its entire interface【54†L1-L9】【54†L11-L18】. This file lists all relevant endpoints (AI router, schema catalog, adoption-preview, etc.) and standards (OpenAPI spec, OAuth metadata, AI manifest)【54†L11-L18】【54†L19-L25】. All the “.well-known” routes are implemented: you can fetch /ai-plugin.json, /ai-manifest.json, /ai-router.json without auth. The /exchange API returns a live JSON catalog showing supported packet classes and gate status【53†L21-L29】【53†L72-L75】. In short, it works as a machine-to-machine platform should.

Security headers: Response headers include a strong CSP, HSTS, X-Frame-Options: DENY, etc. No misconfigurations were observed. POST endpoints require Bearer tokens and return structured 401 challenges. The “Memory Firewall” algorithm appears to screen content (it explicitly checks for injection and policy violations【48†L27-L31】).

Performance: On a desktop, the homepage rendered in about ~0.9s (CI-based test). The main home image is 2.33 MB, which is large and slows first paint; compressing it would help. The /exchange interactive page makes a ~200KB JSON fetch on user action – fine for now, but should be split by functionality (catalog vs preview vs graph) in future to save bandwidth. There is a third-party error-reporting script adding overhead (monitor this).

Issues:

• No sitemap.xml or robots.txt: (404 on /sitemap.xml). Add a sitemap and canonical tags for SEO.
• Mobile overflow: As noted, tables (e.g. event ledger) overflow on narrow viewports – fix via responsive CSS or accordion views.
• No analytics/product metrics: There’s no user tracking or funnel. We have no idea how many people try the preview, how many sign up, etc. Adding even basic analytics is a priority.
• Monolithic POC deploy: Currently it looks like a simple WSGI/cPanel app. For scale, it needs CI/CD, containerization, horizontal scaling.

Engineer's to-do (urgent): Run a CI check after deployment using the verify_public_agent_routes.py script to catch any broken endpoints. Enable gzip or Brotli on static assets (especially the hero image). Put a simple “All systems nominal” status indicator. Split up the monolithic JSON payloads. Add persistent storage (so adoption events and analytics are kept, not just logs).

Conversion & Growth Analysis

Current funnel: Anonymous visitor → reads conceptual homepage → maybe clicks “Enter Exchange” → tries demo → then stuck (no login or continuation). There is effectively no activation loop. Without accounts or saved artifacts, users have zero reason to return. Anyone who tries the preview can do one off-check (like we did), but then there’s nothing to save or share.

No sharing or collaboration: Without report export, badge, or community feature, users can’t easily bring teammates or show results to stakeholders. There’s no channel for referral. A big missed opportunity is a “Packet Safety Report” page that can be shared or published (e.g. on a public directory).

Monetization surface: Currently, nothing indicates pricing or limits. The natural tiers (as hinted by business logic) might be:

• Free/public: Anyone can run the sample checker or browse public packets.
• Developer: Paid API keys, private packet checks, saved reports.
• Team: Multi-user orgs with approval queues, policy enforcement, SSO.
• Enterprise: Private registry, retention policies, compliance audits.

Growth loops: A shareable, credible artifact is key. For example, generating a PDF report that is “NeuralWikis Certified Safe Packet” could be posted on GitHub, Twitter, etc. A “Verified by NeuralWikis” badge on packet authors’ repos. Integrations like a GitHub Action scanning memory files and attaching a NeuralWikis report. Template galleries of community-created safe persona packets. These would turn users into promoters.

Metrics to track: Activation should be defined as “import a packet and get a report”. So track: (a) how many packets checked per visit, (b) conversions to signed-up user (once signup exists), (c) report downloads/shares. With no saved state, current funnel conversion is essentially 0%.

What’s Missing

Key product pieces still missing:

• Signup & API Keys: No public registration or developer key generation exists.
• Packet Upload: You can only pick from existing packets; no “paste your JSON” or file upload.
• Saved Reports/Workspace: No concept of saving a report or revisiting it. All output is ephemeral.
• Team/Org features: No collaboration, approvals, or roles.
• Pricing or Trust page: No indication of cost, SLAs, compliance.
• Changelog/Updates: No news or release notes.
• User/customer proof: No testimonials, case studies, or even an about page.

Missing the drama: The site is full of “trust architecture” language, but never shows a scary story. For instance, a quick example: “Imagine an agent importing unvetted memory that contains a private client’s secret data – NeuraWiki’s firewall would block that.” A concrete vignette or demo video (before/after adoption gone wrong vs safe) would hit the emotional hook.

Highest-leverage feature: Without doubt, a live “Packet Safety Check” must be built: a single form where you paste a JSON packet and immediately see a colorful report (risk ★★☆☆☆, compatibility ★★★☆☆, blockers listed). This demo should be front-and-center. It translates the abstract “infrastructure” into an outcome like “Saved you from data leak.”

Product Strategy Recommendation

Ideal users: AI platform engineers and architects building multi-agent systems. E.g. small AI startups or internal teams (10–500 people) that deploy autonomous bots with shared knowledge. They need to verify and audit what memory, skills, and personas go into each agent.

Key use cases:

• Pre-flight reviewing of agent “brain packages” (memories or instructions) before deployment.
• Testing a new persona/skill across different models (GPT, Claude, Gemini) for compatibility.
• Enforcing an approval workflow for any AI context change (e.g. compliance officers sign off on new prompts).
• Sharing and publishing “trusted agent packets” internally or publicly.

Positioning statement: “NeuralWikis is the trust layer for AI-agent context adoption. It helps teams verify, simulate, approve and roll back memory, persona, skill and protocol packets before they change agent behavior.” This frames it as a necessary pipeline component, not a standalone chat tool.

Why now: AI agents are moving into production (e.g. customer support bots, developer assistants). As they ingest more user data and knowledge, the risk of them “going rogue” increases. NeuralWikis would be the safety net in this new pipeline: before trusting an agent with new context, have NeuralWikis certify it.

Vision: Ultimately, envision a decentralized “packet registry” (like npm but with security seals): every AI context package on the planet is signed, scored, and discoverable. Imagine “AI Tools Directory” meets OWASP but for agent knowledge. But first, get the basic trust workflow nailed.

Prioritized Roadmap

• Deploy static agent manifests and run a public-route verifier on them (ensures /robots.txt, /ai.txt, etc. stay correct). Impact: high safety; Effort: low. • Add /sitemap.xml and <link rel=canonical> tags. Impact: medium (SEO/funnel); low effort. • Fix mobile table overflow via CSS. Impact: high usability; low effort. • Rename primary CTA: change “Inspect Exchange Model” to “Run a Packet Safety Check” to focus on action. Impact: high clarity; low effort. • Status indicator: Show backend/API health (like “Exchange API OK”) in footer. Impact: medium trust; low effort.

• Next 24 hours (quick wins):

• Public sample checker (no auth): Build the 3-step demo (preloaded sample packet, simulate, report). Impact: very high user conversion; moderate effort. • User accounts & API keys: Enable signup and key issuance, even if simple (email + password). Impact: high (funnel start); moderate-high effort. • Saved reports: Allow logged-in users to save and name a safety check report, with a sharable link. Impact: high engagement; moderate effort. • Deep-links & Docs: Create individual pages for each packet/profile (so search results go somewhere meaningful). Flesh out API docs (Swagger UI from .well-known/openapi.yaml). Impact: high usability; medium effort. • Trust/Compliance pages: Add a “Security & Compliance” page listing SOC 2, GDPR, etc, mirroring competitors.【12†L327-L334】. Add team bios or advisors to build credibility. Impact: medium trust; medium effort.

• Next 30 days:

• Private registries & orgs: Implement multi-tenant orgs, roles, and private packet registries with approvals/workflows. Impact: very high (enterprise-ready); high difficulty. • Model compatibility matrix: Let users simulate a packet against multiple model profiles (e.g. “Run against GPT-4, Claude 3, Gemini” with comparative output). Impact: high; high effort. • Integrations: Release a GitHub Action and/or CLI tool that auto-submits packet files for scanning, returning a badge/report. Impact: high adoption; medium-high effort. • Analytics dashboards: Track user actions (packet checks run, API key creation, etc.) and funnel metrics. Impact: high insight; moderate effort.

• Next 90 days:

• Enterprise trust engine: Build a full policy engine where companies define custom rules (whitelists, DIDs, retention). Export audit logs. Impact: huge; very hard. • Standardize packet formats: Lead or join an industry effort to define JSON schemas for Persona, Memory, Skill packets. Become the “PKG spec” maintainers. Impact: strategic; very high effort. • Market & community: Launch a public “packet registry” marketplace with ratings/provenance. Gamify contributions (badges for “NeuralWikis-certified authors”). Impact: network effect; high difficulty.

• 6–12 months (ambitious):

Key metric: Activation = user imports/selects any packet and gets a risk report within 5 minutes. Aim for a 50% activation rate of demo checkers.

Final Verdict

Promising but not yet ready. The architecture and API groundwork are solid (best-in-class machine interface), but the product experience is incomplete. It currently asks users to explore infrastructure rather than solve a pressing need. If unchanged, it will lose to both established AI ecosystems (which don’t need it) and more polished startups (which sidestep its niche).

The single most transformative step: build the live packet safety checker with a shareable adoption report. Show outcomes, not APIs. Then see if developers actually use it in practice. I would fund it once I saw 20 teams doing exactly that and asking for team/enterprise features. Today, technical users respect it; they’ll love it only when it protects their project from a concrete failure.

Bottom line: NeuralWikis has potential to become the trusted import gateway for AI agent knowledge. But it must shift from “admiring the engine” to “driving the car.” Focus relentlessly on quick user wins and the human side of trust. Executed well, it could become the de facto “npm for AI memory.” If not, it risks staying an interesting demo in a portfolio.

Sources: Feature testing on neuralwikis.com (including /exchange flow, APIs at /api/exchange, /llms.txt, etc.), and public docs/pages from Notion【15†L392-L400】, Perplexity【17†L94-L100】【17†L189-L192】, OpenAI【19†L139-L142】, Obsidian【21†L176-L184】, Mem【27†L409-L411】, Tana【29†L7-L13】【29†L141-L146】, NotebookLM【34†L176-L180】, and Glean【41†L256-L264】.