Forem: Jonomor

Building H.U.N.I.E.: A Persistent Memory Engine for AI Agents

Jonomor — Tue, 28 Apr 2026 03:56:48 +0000

I built H.U.N.I.E. because every AI system in production today has the same fundamental flaw: they forget everything between sessions. Each conversation starts from zero. Each task begins without context. No matter how sophisticated the model, without persistent memory that can be verified and updated, AI agents cannot pursue long-term goals, self-correct over time, or operate autonomously.

H.U.N.I.E. — Human Understanding Neuro Intelligent Experience — solves this foundational problem. It's the persistent memory engine that powers the entire Jonomor ecosystem, providing confidence-aware memory that persists across sessions and properties.

The Core Problem

Traditional AI deployments are stateless. A customer service bot forgets previous interactions. A coding assistant doesn't remember project context. An analysis tool can't build on prior conclusions. This isn't just inconvenient — it's architecturally limiting. Without verified memory, AI systems cannot learn from experience, maintain consistent behavior, or collaborate effectively across different contexts.

The problem compounds in multi-agent systems. When different AI properties need to share intelligence, there's no unified memory layer. Each system maintains its own context, leading to contradictory conclusions and duplicated effort.

Architecture Decisions

H.U.N.I.E. addresses this through a dual-layer architecture built on PostgreSQL and TypeScript. The Knowledge Graph Layer stores structured facts and relationships — entities, attributes, connections between concepts. The Conversational Context Layer maintains dialogue history and interaction patterns.

These layers are unified by a consolidation engine that evaluates every incoming write against existing memory. When new information arrives, the engine checks for contradictions with established facts, merges duplicates, and recalculates confidence scores. This isn't just storage — it's active memory management.

Every piece of information in H.U.N.I.E. carries a confidence score from 0.0 to 1.0. This isn't an arbitrary rating. The system tracks provenance, cross-references sources, and updates confidence based on corroborating or conflicting evidence. When an AI agent queries H.U.N.I.E., it receives not just information, but calibrated uncertainty.

Query Architecture

H.U.N.I.E. supports four distinct query types, each optimized for different access patterns:

Semantic queries use vector similarity to find conceptually related information, even when exact matches don't exist. Structured queries leverage traditional database operations for precise fact retrieval. Graph traversal explores relationships and connections between entities. Entity queries focus on specific objects and their attributes.

This multi-modal approach means AI agents can access memory the way the task demands — sometimes you need exact facts, sometimes you need to explore connections, sometimes you need conceptually similar information.

Ecosystem Integration

H.U.N.I.E. serves as the central nervous system for the Jonomor ecosystem. All nine properties read from and write to the same unified memory layer. When one property learns something new, that knowledge becomes available to all others through the consolidation engine.

Namespace isolation ensures different projects and contexts remain separate while still enabling cross-property intelligence when appropriate. A signal detected in one property can inform analysis in another, but only through controlled channels.

The system runs on Railway with PostgreSQL as the primary data store. The technology stack is intentionally straightforward — TypeScript and Node.js — because the complexity lives in the consolidation algorithms and confidence modeling, not in exotic infrastructure.

Memory Integrity

The consolidation engine is what makes H.U.N.I.E. more than just a database. It actively manages memory integrity by detecting contradictions, preventing duplicate storage, and maintaining confidence calibration. When conflicting information arrives, the system doesn't just store both versions — it flags the contradiction and adjusts confidence scores accordingly.

This approach enables AI agents to work with uncertain information while understanding the limits of their knowledge. Instead of hallucinating with false confidence, agents can acknowledge uncertainty and seek additional verification when confidence scores are low.

H.U.N.I.E. transforms stateless AI interactions into persistent, learning systems. It's the foundation layer that makes long-term AI autonomy possible.

Learn more at https://www.hunie.ai.

Building Evenfield: An AI Homeschool Platform That Never Forgets

Jonomor — Tue, 28 Apr 2026 03:54:31 +0000

I built Evenfield because existing educational platforms treat every session like the first session. A student struggles with fractions in September, makes progress through October, then encounters decimals in November — and the AI tutor has no memory of that fraction journey. This fundamental limitation turns personalized learning into a series of disconnected interactions.

Evenfield solves this by maintaining persistent memory across every tutoring session. Built on Anthropic's Claude and powered by our H.U.N.I.E. memory layer, it's an AI-powered homeschool platform that actually remembers each learner's progress, struggles, breakthroughs, and learning patterns.

The Memory Problem in AI Education

Most AI tutoring platforms operate with session-based memory. Each conversation starts fresh. The AI might adapt within a single session, but by the next day, it's forgotten how the student learns best, which concepts they've mastered, and where they consistently struggle.

This creates a broken learning experience. Real teaching requires understanding not just what a student knows today, but how they got there, what methods worked, and what didn't. Memory isn't a nice-to-have feature in education — it's fundamental to how learning actually works.

Architecture and Technical Decisions

Evenfield runs on Next.js with Supabase handling data persistence and Railway managing deployment. The interface uses Tailwind CSS for responsive design across devices. But the core innovation sits in the integration with H.U.N.I.E., our persistent memory system.

Every tutoring session writes to H.U.N.I.E.'s memory layer. When a learner works through algebra problems, struggles with reading comprehension, or shows aptitude for coding concepts, that information persists. The next session begins with full context of previous interactions.

The AI tutor accesses this accumulated knowledge to make informed decisions about pacing, difficulty adjustment, and instructional approach. It knows if a student learns better through visual examples or verbal explanation, whether they need more practice with foundational concepts, or if they're ready to advance.

Fifteen Subjects, Three Learners

The platform covers fifteen subjects including math, coding, financial literacy, entrepreneurship, AI literacy, Spanish, reading, and science. Each subject maintains its own progression tracking while contributing to a unified learner profile.

Currently serving three learners with two instructors, Evenfield differentiates content by age and skill level. The same algebraic concept gets presented differently to a visual learner versus someone who prefers step-by-step logical progression.

For compliance requirements, the system auto-generates quarterly PDF reports documenting progress across all subjects. These aren't generic templates — they reflect actual learning outcomes tracked through persistent memory.

Integration with the Jonomor Ecosystem

Evenfield represents the first H.U.N.I.E. client application, serving as live proof that persistent AI memory transforms tutoring effectiveness. Each learner operates as an agent that writes to H.U.N.I.E. after every session, building a comprehensive educational profile over time.

This integration demonstrates H.U.N.I.E.'s capability beyond simple data storage. The memory layer understands educational context, maintains learning progression timelines, and enables sophisticated queries about student development patterns.

Building for Real Use

I didn't build Evenfield as a demo or proof of concept. This is the education platform my children use daily. Every feature decision gets validated through actual teaching sessions. Every technical choice supports real learning outcomes.

The platform evolved from immediate needs: tracking progress across multiple subjects, maintaining continuity between sessions, and providing the kind of individualized attention that makes homeschooling effective. The persistent memory capability emerged from watching how human tutors build understanding over time — they remember everything about each student's learning journey.

Evenfield proves that AI tutoring can move beyond session-based interactions toward genuine educational relationships. The technology exists to build systems that truly know their learners.

Learn more at https://www.evenfield.io.

Building AI Presence: Automating the Operational Surface of AI Visibility

Jonomor — Tue, 28 Apr 2026 03:26:22 +0000

Most content automation tools generate generic output. They miss entity names, dilute founder voice, and ignore platform conventions. After building the first five stages of the AI Visibility Framework, I realized Stage 6 — Continuous Signal Surfaces — demanded purpose-built automation.

AI Presence solves this operational problem. Nine content engines generate platform-native content while enforcing exact entity names, founder voice, and locked terminology. Every piece feeds the broader Jonomor intelligence system.

The Technical Problem

Generic content tools fail at precision. They approximate names, lose voice consistency, and output platform-agnostic formats. For AI visibility, this breaks the compounding effect. A press release with the wrong entity name doesn't register in search patterns. A LinkedIn post without platform-native formatting gets buried by algorithms.

The automation must be surgical. Entity names locked to exact strings. Founder voice trained on specific samples. Output formatted for LinkedIn's algorithm, not just LinkedIn's interface. Reddit posts that follow subreddit conventions. X threads that use platform mechanics correctly.

Architecture Decisions

I built AI Presence on Next.js 14 with TypeScript for type safety across complex content generation workflows. The Anthropic Claude API handles content generation with custom system prompts per engine. OpenAI DALL-E 3 generates visual assets when needed.

Supabase provides the database layer, storing content templates, entity definitions, and tracking data across the five-state outreach lifecycle. Stripe handles billing for the multi-tenant SaaS deployment.

The nine content engines operate independently but share core enforcement logic:

Entity Name Enforcement: Every generated piece runs through validation layers that lock entity names to exact strings. No approximations or variations.

Voice Training: Each engine loads founder voice samples and terminology constraints before generation. The system maintains consistency across all content types.

Platform-Native Formatting: LinkedIn posts include hashtags and professional tone. Reddit posts match subreddit conventions. X threads use proper thread mechanics. Each engine knows its platform.

Operational Intelligence

AI Presence tracks everything. Outreach management follows pitches through five states: draft, sent, responded, rejected, placed. Mention tracking scores every placement with authority weighting across seven types of coverage.

The AI citation monitoring runs retrieval cycles across ChatGPT, Perplexity, Gemini, and Copilot. When your entity gets cited in AI responses, the system captures and scores the placement.

All tracking data flows into H.U.N.I.E., the Jonomor intelligence system. Every operation compounds. Successful outreach patterns inform future pitches. Mention scores reveal which content formats generate authority. Citation data shows AI model knowledge evolution.

Ecosystem Integration

AI Presence serves as the operational surface for the Jonomor ecosystem. It reads cross-property intelligence from scanner data, retrieval signals, legal patterns, and network state. This intelligence informs content generation and outreach targeting.

The press kit generator pulls data from multiple ecosystem properties to create comprehensive media packages. The trend commentary engine processes real-time signals to generate timely insights. Each engine leverages the full intelligence stack.

Multi-Tenant SaaS

Unlike other Jonomor properties built for single entities, AI Presence operates as multi-tenant SaaS. Companies can onboard their entities, train their voice, and automate their signal surfaces without building internal systems.

The platform enforces isolation between tenants while sharing core engine capabilities. Each organization gets independent entity management, voice training, and tracking dashboards.

Stage 6 of the AI Visibility Framework cannot be automated with generic tools. The precision requirements demand purpose-built systems. AI Presence provides that precision while feeding intelligence back into the broader ecosystem.

Try AI Presence at https://www.ai-presence.app.

Building Forensic Infrastructure Research: The Neutral Bridge

Jonomor — Tue, 28 Apr 2026 03:25:05 +0000

I built The Neutral Bridge because the public discourse around XRP and Ripple has become noise. Price predictions, moon charts, regulatory theater — none of it examines the actual infrastructure transformation happening beneath the surface. The financial engineering required to re-architect global settlement systems deserves forensic analysis, not speculation.

The Neutral Bridge is infrastructure research. It analyzes how settlement systems work, why they are changing, and what that transformation means for global finance. This is not market commentary. It is forensic-grade analysis of the engineering decisions reshaping how money moves between institutions.

The Technical Problem

Traditional financial infrastructure research operates on static data and quarterly reports. Settlement systems like the XRP Ledger operate in real-time, with network state changes happening every 3-4 seconds. Analyzing this infrastructure requires live data integration, not historical snapshots.

Most analysis of XRPL focuses on price movements or transaction volume. The actual infrastructure metrics — validator network health, fee market dynamics, ledger consensus performance — receive minimal attention. These are the metrics that matter when evaluating settlement system reliability.

Architecture Decisions

The Neutral Bridge runs on a lean stack: Vite and React 18 for the frontend, deployed on GitHub Pages. The real complexity lies in the data pipeline architecture.

The platform integrates live XRPL network state through XRNotify, another component in the Jonomor ecosystem. XRNotify monitors validator changes, fee trends, and ledger performance metrics in real-time. This data flows through H.U.N.I.E.'s shared memory system, allowing The Neutral Bridge to access current network state without maintaining separate monitoring infrastructure.

The blog component uses the Gemini API for content generation, combined with CoinGecko API for market context when relevant. The automation adapts to network events — validator changes trigger analysis posts, fee market shifts generate infrastructure impact assessments. This is not scheduled content. It responds to actual network events.

Ecosystem Integration

The Neutral Bridge operates as both consumer and contributor within the Jonomor ecosystem. It reads network state data from XRNotify through H.U.N.I.E.'s intelligence layer. When regulatory developments impact XRPL infrastructure, those findings feed back into the shared intelligence system.

This bidirectional data flow creates a feedback loop. Network monitoring informs regulatory analysis. Regulatory findings contextualize network changes. The result is infrastructure research grounded in both technical reality and regulatory environment.

Publication Results

The Neutral Bridge achieved #1 New Release in Financial Engineering on Amazon in February 2026. The publication is available in both retail and institutional editions. The retail edition focuses on accessible infrastructure analysis. The institutional edition includes technical appendices and regulatory compliance frameworks.

The success validates the market need for serious infrastructure research. Financial institutions require forensic analysis of settlement systems they might adopt. Developers need technical documentation of network behavior. Both audiences were underserved by existing XRPL analysis.

Implementation Details

The live data integration required solving memory management challenges. XRPL generates significant data volume — transaction metadata, validator consensus messages, fee market changes. H.U.N.I.E.'s shared memory architecture allows The Neutral Bridge to access this data stream without duplicating storage or processing overhead.

The automated blog system filters network events for infrastructure significance. Not every validator change warrants analysis. Not every fee adjustment indicates market shift. The filtering logic focuses on events that impact settlement system reliability or regulatory compliance.

Building Infrastructure Research

The Neutral Bridge demonstrates that technical infrastructure deserves technical analysis. Settlement systems are engineering projects. They should be evaluated using engineering methodology, not financial speculation.

The platform continues expanding its forensic capabilities. Network stress testing analysis, validator performance benchmarking, consensus mechanism evaluation — these are the tools required for serious infrastructure research.

Financial infrastructure is being re-engineered in real-time. The analysis should be equally real-time.

https://www.theneutralbridge.com

Building Compliance-First Property Management Software

Jonomor — Tue, 28 Apr 2026 03:23:15 +0000

Most property management software treats compliance like a checkbox feature. You run your operations in one system, then export data to create compliance reports when auditors come knocking. This backward approach creates gaps, inconsistencies, and the kind of scrambling that happens during inspections.

I built MyPropOps because compliance shouldn't be an afterthought—it should be the foundation.

The Architecture Decision

The core architectural choice was building compliance into the data model from the beginning. Every action in MyPropOps—maintenance requests, tenant communications, document uploads, inspection records—creates immutable audit trails as a byproduct of normal operations.

When a tenant reports a maintenance issue through the tenant portal, the system doesn't just create a work order. It generates a timestamped record of the initial report, tracks every status change, logs all communications between manager and contractor, and documents the resolution with photos and notes. If HUD walks in tomorrow, you have a complete chain of custody for every maintenance action.

The inspection module uses HUD-ready templates, not generic checklists adapted after the fact. These templates map directly to the compliance requirements property managers actually face. Complete an inspection in MyPropOps, and you have documentation that meets federal standards without additional formatting or data massage.

Three-Portal Design

The system uses separate portals for managers, tenants, and contractors—each seeing exactly what they need and nothing more. Tenants submit maintenance requests and view their lease documents. Contractors receive work orders with property access details and submit completion reports with photos. Managers coordinate between both while maintaining full oversight.

This separation isn't just about user experience. It creates clear boundaries for data access and generates cleaner audit trails. When a contractor marks work complete, the system captures not just the completion time but which contractor performed the work, what materials were used, and whether the tenant confirmed satisfaction.

Technical Implementation

The backend runs on FastAPI with MongoDB for document storage. Property management generates a lot of unstructured data—photos, PDF documents, inspection notes, communication histories. MongoDB handles this variety without forcing everything into rigid relational tables.

The React frontend provides responsive interfaces for each portal type. Capacitor wraps the web app for mobile deployment, letting contractors and managers access the system from job sites without maintaining separate native apps.

Stripe handles payment processing for rent collection and maintenance charges. The integration creates payment audit trails that connect directly to tenant accounts and property financials.

Ecosystem Integration

MyPropOps connects to two other Jonomor products. It reads lease clause risk intelligence from Guard-Clause, flagging potential compliance issues based on lease language. When Guard-Clause identifies clauses that create maintenance obligations or tenant communication requirements, MyPropOps surfaces these as active compliance tasks.

The system feeds operational data to H.U.N.I.E. for predictive analysis. Maintenance patterns, tenant behavior data, and vacancy rates flow to H.U.N.I.E., which identifies trends like recurring maintenance issues or early indicators of tenant problems.

The Compliance-First Difference

Traditional property management software asks you to manage properties, then figure out compliance reporting separately. MyPropOps reverses this: manage properties through compliance-ready processes, and operations become simpler, not more complex.

Every maintenance action creates a complete record. Every tenant interaction has a timestamp and context. Every document connects to the relevant property and tenant account. When auditors arrive, you provide access to the system rather than scrambling to compile reports.

This approach reduces both compliance risk and operational overhead. Property managers spend less time on documentation because documentation happens automatically. Audit preparation becomes a matter of generating reports, not reconstructing events from scattered records.

Check out MyPropOps at https://www.mypropops.com.

Building XRNotify: Webhook Infrastructure for the XRP Ledger

Jonomor — Mon, 27 Apr 2026 06:39:25 +0000

I built XRNotify because every XRPL developer I talked to was solving the same problem over and over: monitoring wallet activity and transaction events on the XRP Ledger. Everyone was rolling their own listener infrastructure from scratch, dealing with connection drops, implementing retry logic, and handling edge cases that only surface in production.

The result was predictable: brittle systems with no monitoring, failed event deliveries going unnoticed, and developers spending time on infrastructure instead of building features.

The Technical Problem

The XRP Ledger is event-driven by design. Wallets receive payments, escrows execute, trust lines change, NFTs transfer. Applications need to react to these events in real-time, but the XRPL WebSocket connection requires constant babysitting.

Connection drops happen. Network partitions occur. Your application might miss critical events, and you won't know until users start complaining. Building reliable listener infrastructure means handling reconnection logic, maintaining state across restarts, implementing exponential backoff, and creating monitoring systems to catch failures.

Most developers skip these details initially, then spend months retrofitting reliability into systems that were never designed for it.

Architecture Decisions

XRNotify handles the entire pipeline from XRPL event detection to webhook delivery. The architecture separates concerns cleanly:

Event Detection Layer: Node.js workers maintain persistent connections to XRPL nodes, handling reconnections and state reconciliation automatically. When connections drop, workers detect the gap and backfill missed events from ledger history.

Event Processing: PostgreSQL stores event data with proper indexing for wallet lookups and historical queries. Redis handles the delivery queue, tracking retry attempts and managing exponential backoff timing.

Delivery Infrastructure: The webhook delivery system implements enterprise-grade reliability patterns. Failed deliveries trigger exponential backoff retry (1s, 2s, 4s, 8s, up to 256s intervals). After exhausting retries, events move to a dead-letter queue for manual investigation.

Every webhook payload includes HMAC-SHA256 signatures for verification. Developers can trust that webhook calls originated from XRNotify and haven't been tampered with in transit.

Event Categories and Types

XRNotify monitors 22+ event types across 7 categories: payments, escrows, checks, NFTs, DEX activity, trust lines, and account settings. Each event type captures the specific data developers need without requiring them to parse raw XRPL transaction formats.

For example, a payment event includes sender, recipient, amount, currency, destination tag, and memo fields. An escrow creation event includes the escrow sequence, destination, amount, condition hash, and execution timeframe.

Ecosystem Integration

XRNotify serves as the nervous system for the broader Jonomor ecosystem. Network state data flows to The Neutral Bridge, where it supports financial infrastructure research and cross-chain analytics.

Anomaly patterns detected in transaction flows feed into H.U.N.I.E.'s intelligence layer, helping identify unusual network behavior or potential security issues. XRNotify also powers the circuit breaker mechanism in H.U.N.I.E. Sentinel, automatically triggering protective measures when transaction patterns indicate potential threats.

This integration creates value beyond simple webhook delivery. The same infrastructure that powers your application's event handling contributes to broader network intelligence and security research.

Getting Started

XRNotify eliminates the infrastructure overhead of XRPL event monitoring. Instead of building and maintaining your own listener infrastructure, you configure webhook endpoints and start receiving events immediately.

The platform handles all the reliability concerns: retry logic, failure monitoring, signature verification, and delivery guarantees. You focus on building features, not babysitting WebSocket connections.

Try XRNotify

Building Guard-Clause: AI Contract Analysis Without the Legal Team

Jonomor — Mon, 27 Apr 2026 06:37:40 +0000

I built Guard-Clause because contract review shouldn't require retaining a law firm. Individual professionals and small businesses face the same complex legal documents as Fortune 500 companies, but they don't have teams of attorneys to parse through 40-page service agreements or identify buried liability clauses.

Guard-Clause is an AI-powered contract analysis platform that reads any legal document and returns structured risk findings at the clause level. It's not another document viewer that highlights keywords. It's an analysis engine that applies a defined methodology to unstructured legal text and delivers actionable intelligence.

The Technical Problem

Legal contracts are unstructured data masquerading as structured documents. A liability limitation clause might appear on page 12 of one contract and page 3 of another. The language varies between "Company shall not be liable" and "In no event will Provider be responsible for" but the legal implications are identical.

Traditional contract review relies on human pattern recognition. Lawyers scan documents looking for problematic language based on experience. This works, but it doesn't scale and it's expensive. The core challenge is converting unstructured legal text into structured risk data that can be analyzed, scored, and acted upon.

Architecture Decisions

I built Guard-Clause on Next.js 15 with Supabase handling authentication and data persistence. The analysis engine uses Anthropic's Claude API, which handles complex legal reasoning better than other models I tested.

The privacy architecture was foundational, not an afterthought. All contract data flows through an ephemeral Redis cache with a 15-minute TTL. When you upload a contract, it gets processed immediately and the source document is purged automatically. No contract content touches permanent storage. This isn't privacy as a feature toggle - it's privacy by default.

The analysis pipeline works like this: document ingestion, clause extraction, risk classification, severity scoring, and output generation. Each clause gets evaluated against legal risk patterns and assigned a severity level (Critical/High/Medium/Low). The system generates negotiation scripts and replacement language for problematic clauses.

Structured Analysis Output

Guard-Clause doesn't just flag potential issues. It delivers structured analysis that includes:

Clause-level risk scoring with specific severity classifications
Negotiation scripts tailored to each problematic clause
Replacement language that maintains commercial intent while reducing risk
Addendum generation for comprehensive contract modifications
Multi-persona analysis (buyer vs. seller perspective)

This structured approach means you get actionable intelligence, not just highlighted text. You know what's wrong, why it's wrong, and how to fix it.

Ecosystem Integration

Guard-Clause feeds into the broader Jonomor ecosystem. Every analysis generates legal pattern intelligence that flows to H.U.N.I.E., the ecosystem's central memory engine. As more contracts get analyzed, the accumulated pattern data compounds into institutional-grade legal intelligence.

MyPropOps, another tool in the ecosystem, reads Guard-Clause patterns when reviewing lease clauses. This creates a feedback loop where contract analysis improves property operations and vice versa.

Implementation Details

The tech stack prioritizes reliability over complexity. Stripe handles payments, Redis manages the ephemeral cache, and Supabase provides the data layer. I chose proven tools because contract analysis requires consistent uptime - you can't debug infrastructure when someone needs a contract reviewed for a morning meeting.

The Claude API integration required careful prompt engineering to ensure consistent output structure. Legal language is nuanced, and the model needed training on how to classify risk severity and generate practical negotiation guidance.

Why This Matters

Large enterprises have legal teams and contract management systems. Everyone else has been making do with manual review or ignoring contract risks entirely. Guard-Clause democratizes contract intelligence by making professional-grade analysis accessible to individual professionals and small businesses.

The platform launches with support for standard business contracts: service agreements, NDAs, employment contracts, and vendor agreements. More specialized contract types will follow based on user demand.

Check out Guard-Clause at https://www.guard-clause.com.

Building AI Visibility Infrastructure: The Technical Foundation Behind Jonomor

Jonomor — Mon, 27 Apr 2026 06:35:14 +0000

When ChatGPT, Perplexity, or Copilot answers a question, they're not searching the web like Google. They're retrieving structured knowledge from entity graphs. This fundamental difference breaks traditional SEO assumptions and creates a new optimization challenge: getting your organization cited by AI answer engines.

I built Jonomor to solve this problem systematically. Not through content volume or keyword density, but through entity architecture and what I call AI Visibility infrastructure.

The Technical Problem

AI answer engines operate on knowledge graphs, not page rankings. When you ask ChatGPT about a company or concept, it's pulling from pre-indexed entity relationships, not crawling websites in real time. This means optimization requires structured data, entity relationships, and authority signals that traditional SEO tools don't measure.

The gap is structural. SEO professionals optimize for search rankings while AI systems retrieve from knowledge bases. Content volume matters less than entity clarity. Link building matters less than reference surface distribution. Page speed matters less than schema graph completeness.

The AI Visibility Framework

I developed a six-stage, 50-point scoring methodology that measures what AI answer engines actually evaluate:

Entity Stability - Clear identity markers, consistent naming, structured data markup
Category Ownership - Authority within specific domains, topical clustering
Schema Graph - Interconnected structured data, relationship mapping
Reference Surfaces - Distribution across platforms where AI systems index
Knowledge Index - Presence in authoritative knowledge bases
Continuous Signal Surfaces - Ongoing entity activity and validation

Each stage contributes specific technical requirements. Entity Stability requires JSON-LD structured data with proper @type declarations. Schema Graph demands hasPart/isPartOf relationships between connected entities. Reference Surfaces need distribution beyond owned domains.

Architecture Decisions

Rather than build theoretical frameworks, I implemented AI Visibility across nine production properties. Each property serves a different market but shares the same entity architecture foundation through H.U.N.I.E., a central memory engine that maintains entity relationships across the entire ecosystem.

The technical stack centers on Next.js and TypeScript for consistent entity markup generation. Every property implements identical structured data patterns, ensuring schema graph connectivity. Railway handles deployment infrastructure, while Anthropic's Claude API powers the automated AI Visibility Scorer.

The scorer evaluates any public domain against the 50-point framework in real time. It crawls structured data, analyzes entity relationships, checks reference surface distribution, and measures authority signals. This provides immediate feedback on AI Visibility implementation.

Production Validation

Seven of the nine Jonomor properties score 48/50 Authority on the AI Visibility Framework. This isn't theoretical - these are production systems handling real users and generating actual citations from AI answer engines.

Guard-Clause analyzes AI contracts, XRNotify provides XRPL webhook infrastructure, MyPropOps manages properties, The Neutral Bridge researches financial infrastructure. Each property maintains its own market focus while contributing to the shared entity graph.

The H.U.N.I.E. memory layer connects all properties through structured relationships. When one property establishes authority in its category, that authority propagates through the entity graph to connected properties. This creates compound AI Visibility effects.

Beyond Optimization

Traditional optimization treats search engines as external systems to influence. AI Visibility treats answer engines as knowledge systems to join. The difference shapes every technical decision - from how we structure data to how we measure success.

Entity architecture becomes infrastructure. Reference surfaces become distribution networks. Authority becomes a measurable, transferable asset across connected properties.

This is what Jonomor builds: the frameworks that define AI Visibility as a discipline, the tools that measure and implement it, and the entity architecture that makes it work in production.

The AI Visibility Scorer and complete framework documentation are available at https://www.jonomor.com.

Building XRPL Webhook Infrastructure: XRNotify

Jonomor — Wed, 08 Apr 2026 19:52:04 +0000

Every XRPL developer faces the same problem: reliable event monitoring. You need to know when transactions hit specific wallets, when payment channels update, or when escrows execute. The standard approach means building your own listener infrastructure from scratch.

I built that listener infrastructure four times across different projects. Each time, I dealt with the same issues: connection drops, missed transactions, no retry logic for failed webhook deliveries, and no systematic way to handle edge cases. The XRPL ecosystem needed proper webhook infrastructure.

The Technical Challenge

XRPL moves fast. Transactions settle in 3-5 seconds, and if your listener drops connection or your webhook endpoint goes down, you miss critical events. Building reliable monitoring means solving several problems simultaneously:

Connection resilience to XRPL nodes
Event deduplication and ordering
Webhook delivery with proper retry logic
Signature verification for security
Dead letter queues for failed deliveries

Most developers solve maybe two of these problems well. The rest becomes technical debt that breaks in production.

Architecture Decisions

XRNotify monitors XRPL through persistent WebSocket connections to multiple nodes. The core infrastructure runs on Node.js workers that maintain these connections and process events in real-time.

PostgreSQL stores event history and webhook configurations. Redis handles the event queue and caching layer. When events match configured criteria, they flow through a delivery pipeline with exponential backoff retry logic.

Each webhook payload includes HMAC-SHA256 signatures generated with the customer's secret key. Failed deliveries move to a dead letter queue after exhausting retries. The system tracks delivery status and provides debugging information through the dashboard.

The event categorization covers seven major areas: payments, escrows, payment channels, NFTs, AMM operations, network state changes, and custom transaction monitoring. Within these categories, XRNotify supports 22+ specific event types.

Integration Patterns

The most common pattern is wallet activity monitoring. Developers configure webhooks for specific addresses and receive events when transactions affect those wallets. This covers payments, token transfers, escrow operations, and NFT trades.

Payment channel monitoring represents another key use case. Applications need to know when channels open, receive claims, or close. XRNotify delivers these events with transaction details and state changes included.

Network state monitoring helps infrastructure providers track validator changes, fee updates, and amendment voting. These events feed into broader system health monitoring.

Ecosystem Connections

XRNotify generates network state data that flows to The Neutral Bridge for financial infrastructure research. When transaction patterns indicate potential issues, those anomaly signals feed into H.U.N.I.E.'s intelligence layer.

The Circuit Breaker component in H.U.N.I.E. Sentinel relies on XRNotify's real-time monitoring to detect unusual activity patterns and trigger protective measures when needed.

This integration approach means the webhook infrastructure serves dual purposes: individual developer needs and ecosystem-wide intelligence gathering.

Technical Implementation

The Next.js 14 frontend provides webhook management and event debugging tools. Developers configure endpoints, view delivery logs, and test webhook signatures through the dashboard.

XRPL.js handles all ledger interactions. The worker processes maintain redundant connections to prevent single points of failure. Event processing includes validation against XRPL transaction formats and automatic retries for network hiccups.

Rate limiting and delivery scheduling prevent webhook endpoints from getting overwhelmed during high-activity periods.

Solving Infrastructure Debt

Before XRNotify, XRPL developers built monitoring systems that worked until they didn't. Connection drops meant missed transactions. Failed webhook deliveries disappeared without trace. Debugging required diving through logs with limited visibility.

XRNotify consolidates this infrastructure layer. Developers configure their events and endpoints, then receive reliable delivery with full debugging support. The monitoring infrastructure becomes operational overhead someone else maintains.

Check out XRNotify

Building Guard-Clause: AI-Powered Contract Analysis Without the Legal Team

Jonomor — Wed, 08 Apr 2026 19:51:11 +0000

Contracts are everywhere in business, but analyzing them shouldn't require a law degree or a legal team on retainer. I built Guard-Clause to solve a fundamental problem: individual professionals and small businesses face the same complex contracts as large enterprises, but without the resources to properly analyze them.

Guard-Clause is an AI-powered contract analysis platform that reads any contract and returns clause-level risk findings with severity scoring, negotiation scripts, and replacement language. It's not a document viewer or keyword highlighter. It's a structured analysis engine that applies a defined methodology to unstructured legal text.

The Technical Problem

Most contract tools are built around document management or simple keyword matching. They miss the structural analysis that legal professionals perform when reviewing agreements. A clause isn't risky because it contains certain words—it's risky because of its relationship to other clauses, its enforceability, and its impact on business operations.

The challenge was building a system that could understand legal context, identify problematic patterns, and provide actionable guidance without requiring users to interpret legal jargon themselves.

Architecture Decisions

I built Guard-Clause on Next.js 15 with Supabase for data persistence and Stripe for payments. The core analysis engine runs on Anthropic's Claude API, chosen for its strong performance on complex text analysis tasks.

The privacy architecture was foundational, not an afterthought. All contract data flows through an ephemeral Redis cache with a 15-minute TTL. No contract content is permanently stored. Analysis results are delivered in real time, and the source document is automatically purged. This is privacy by default, not privacy as a feature toggle.

This approach required careful orchestration. The system had to process documents, extract clauses, analyze risk patterns, generate negotiation scripts, and deliver results—all within the ephemeral window. The Redis implementation handles this through structured job queues that track analysis state without persisting source material.

How It Works

Users upload a contract and Guard-Clause performs clause-level analysis across multiple dimensions. Each clause receives a severity classification: Critical, High, Medium, or Low risk. For problematic clauses, the system generates specific negotiation scripts and suggests replacement language.

The analysis engine doesn't just flag issues—it provides context. A liability cap clause might be flagged as high-risk not because liability caps are inherently bad, but because this particular cap is unusually low relative to the contract value, or because it excludes categories that should be covered.

Multi-persona analysis allows users to view contracts through different lenses: buyer, seller, contractor, or client. The same clause can present different risk profiles depending on your position in the transaction.

Ecosystem Integration

Guard-Clause operates within the Jonomor ecosystem, feeding legal pattern intelligence to H.U.N.I.E., the central memory engine. This creates compound value—each contract analysis contributes to institutional-grade legal intelligence that improves future analysis.

MyPropOps, another platform in the ecosystem, reads Guard-Clause patterns when reviewing lease clauses. A property manager analyzing a commercial lease benefits from patterns learned across thousands of previous contract reviews.

Technical Implementation

The analysis pipeline processes contracts through several stages: document parsing, clause extraction, risk assessment, and recommendation generation. Each stage operates independently, allowing for parallel processing where possible.

The severity scoring system uses weighted risk factors rather than binary classifications. A clause might score high on financial exposure but low on enforceability risk. The final severity rating reflects the compound risk profile, not just individual factors.

Addendum generation was particularly complex to implement. The system needs to understand which clauses can be modified through addenda versus those requiring direct contract amendment, then generate legally coherent language that addresses identified risks.

Why This Matters

Contract analysis shouldn't be a luxury service available only to large organizations. Small businesses negotiate software licenses, consulting agreements, and vendor contracts daily. Individual professionals sign employment agreements, consulting contracts, and partnership deals. They deserve the same quality of legal intelligence that Fortune 500 companies get from their legal teams.

Guard-Clause democratizes contract intelligence without compromising on privacy or analytical depth. It's contract analysis for everyone else.

Try it yourself: https://www.guard-clause.com

Building AI Visibility Infrastructure: Inside Jonomor's Architecture

Jonomor — Wed, 08 Apr 2026 19:49:56 +0000

I built Jonomor because the industry was solving the wrong problem. SEO professionals kept optimizing for rankings while AI answer engines like ChatGPT, Perplexity, and Gemini were pulling citations from knowledge graphs. The fundamental disconnect is structural — AI engines retrieve entities, not content volume.

The Technical Problem

When you ask ChatGPT about property management software or XRPL webhooks, it doesn't scan web pages like Google. It queries its knowledge graph for entities that match semantic patterns. Traditional SEO assumes crawlers parse content linearly. AI engines work differently — they map entity relationships and surface authoritative sources through graph traversal.

The gap creates a citation problem. Organizations with strong SEO metrics get ignored by AI answer engines because their entity architecture is weak. Meanwhile, domains with clear entity definitions and stable schema relationships consistently get cited, regardless of traditional ranking factors.

The AI Visibility Framework

I developed a six-stage, 50-point scoring methodology to measure what actually drives AI citations:

Entity Stability evaluates whether your domain maintains consistent identity markers across time. AI engines need stable reference points to build confidence in your authority.

Category Ownership measures semantic association between your entity and specific knowledge domains. The stronger your categorical binding, the more likely AI engines surface you for relevant queries.

Schema Graph analyzes your structured data implementation. Clean schema markup creates clear entity boundaries that AI engines can parse reliably.

Reference Surfaces tracks external validation signals. Citation patterns, backlink authority, and cross-domain entity mentions build cumulative trust.

Knowledge Index measures your content's integration into broader knowledge networks. AI engines prioritize sources that connect well to existing information architectures.

Continuous Signal Surfaces evaluates real-time entity activity. Fresh signals indicate living, authoritative sources rather than static reference material.

Architecture Decisions

Jonomor operates as a hub for nine production properties, each serving different markets while contributing to the overall entity graph. Guard-Clause handles AI contract analysis, XRNotify provides XRPL webhook infrastructure, MyPropOps manages property operations, The Neutral Bridge researches financial infrastructure, Evenfield powers AI homeschool education, and JNS Studios creates children's content.

The technical architecture centers on H.U.N.I.E., a shared intelligence layer that connects all properties. Every domain declares isPartOf Jonomor while Jonomor declares hasPart for each property. This creates clear entity hierarchies that AI engines can map consistently.

I built the automated AI Visibility Scorer to evaluate any public domain against the framework in real time. The tool runs on Next.js with TypeScript, using Anthropic's Claude API for semantic analysis and Railway for deployment infrastructure. Tailwind CSS keeps the interface clean and functional.

Why This Matters for Developers

Four of our domains score 48/50 Authority on the AI Visibility Framework. This isn't accidental — it's the result of deliberate entity architecture decisions. When you build with AI citation in mind, you create systems that both humans and AI engines can understand clearly.

The shift from content optimization to entity optimization changes how we structure applications. Database schemas need to map to knowledge graph patterns. API responses should include structured entity data. Even URL structures should reflect semantic hierarchies rather than arbitrary navigation patterns.

The Ecosystem Approach

Rather than building isolated products, I designed each property to strengthen the overall entity network. When Guard-Clause analyzes contracts, it generates signals that feed back into Jonomor's authority. When XRNotify handles webhooks, it creates technical credibility that supports our infrastructure positioning.

This connected approach means AI engines see Jonomor as a multi-faceted authority rather than a single-purpose domain. The breadth creates trust while the depth in each area maintains relevance.

The infrastructure is working. Our domains consistently get cited by major AI engines for queries in their respective categories. More importantly, the framework provides a replicable methodology for other organizations facing the same citation gap.

AI Visibility is becoming as critical as traditional SEO, but it requires different thinking and different tools. That's what Jonomor provides.

Learn more at https://www.jonomor.com.

Building Forensic Infrastructure Research: The Neutral Bridge

Jonomor — Mon, 06 Apr 2026 16:54:08 +0000

I built The Neutral Bridge because the conversation around Ripple and XRP has been hijacked by price speculation. While traders debate moon shots and crashes, the actual story — how global settlement infrastructure is being systematically re-engineered — gets buried under market noise.

The Neutral Bridge is forensic-grade infrastructure research. Not market commentary. Not investment advice. It examines how settlement systems work, why they're changing, and what that transformation means for global finance.

The Signal-to-Noise Problem

Financial media treats blockchain infrastructure like sports betting. Every announcement gets filtered through price impact speculation instead of technical analysis. This creates a fundamental problem: the people building the next generation of settlement systems can't find serious technical discourse about what they're building on top of.

When I started researching how the XRP Ledger actually processes cross-border payments, I found endless price predictions and almost no forensic analysis of the underlying settlement mechanics. The engineering story was invisible.

Architecture and Data Flow

The Neutral Bridge reads live XRPL network state data through the Jonomor ecosystem's shared intelligence layer. XRNotify monitors validator changes, fee trends, and ledger performance metrics. This data flows through H.U.N.I.E.'s shared memory architecture, where it gets processed and fed into The Neutral Bridge's analysis engine.

The technical stack is deliberately lightweight: Vite with React 18, hosted on GitHub Pages. I chose this over complex backend infrastructure because the heavy lifting happens in the data processing layer, not the presentation layer. The site pulls processed intelligence from the ecosystem rather than trying to be a standalone analysis platform.

The publication includes an automated market-adaptive blog that responds to significant network state changes. When validator consensus shifts or fee structures change, the system flags these events for deeper analysis. This isn't automated content generation — it's automated research prioritization.

Forensic vs. Speculative Analysis

The difference between forensic and speculative analysis is methodology. Speculative analysis starts with a price target and works backward to justify it. Forensic analysis starts with network behavior and works forward to understand what it means.

When analyzing cross-border payment flows, for example, I trace actual transaction paths through the XRPL network. I examine which market makers are providing liquidity, how pathfinding algorithms route payments, and where settlement actually occurs. This reveals how the infrastructure works in practice, not just how it works in theory.

The publication achieved #1 New Release in Financial Engineering on Amazon because this kind of forensic approach fills a gap in financial literature. Most blockchain books are either beginner tutorials or investment guides. Very few examine settlement infrastructure from an engineering perspective.

Ecosystem Integration

The Neutral Bridge doesn't operate in isolation. It's part of a connected intelligence system where network monitoring (XRNotify), data processing (H.U.N.I.E.), and research publication work together. When the analysis identifies regulatory patterns or compliance implications, those findings feed back into the intelligence layer where they inform monitoring priorities.

This creates a feedback loop between observation and analysis. The monitoring system becomes more sophisticated as the research identifies what matters. The research becomes more targeted as the monitoring system identifies what's changing.

Retail and Institutional Editions

The publication comes in two formats. The retail edition focuses on accessible explanations of settlement infrastructure transformation. The institutional edition includes additional technical appendices, regulatory analysis, and network topology data that compliance teams and infrastructure architects need.

Both editions avoid price speculation entirely. The value is in understanding how settlement systems work, not predicting what tokens will do.

This is infrastructure research for builders who need to understand what they're building on top of, regulators who need to understand what they're regulating, and anyone who wants to understand how global settlement is being re-engineered beneath the market noise.

Visit The Neutral Bridge at https://www.theneutralbridge.com.