Simple Agility Stack Hub

Simple Agility is a small-business software stack that lets a company use Generative Artificial Intelligence (GenAI) in a handful of concrete capacities — Search Engine Optimization (SEO) first, proactive customer communication next, with more to follow. It is assembled from separately-developed pieces that already exist and share one data backbone. This hub is the entry point for any human or agent working on any piece of the stack: read it before deciding where a capability belongs.

Ownership principle (the one sentence to remember): every product in the stack optimizes itself by joining its own data against whatever the observability plane makes visible — external signals (search engines, edge analytics) and the product's own error and behavioral events, aggregated back to it. Products do not build their own metrics stores, log stores, alerting, or third-party pollers; the plane does not build product logic.

If you are an agent, start here

You are about to…	Read	Why
Add logging, metrics, health, or events to any product	SimpleAgilityTelemetryContract	The envelope, the correlation_id rules, and the one mistake that damages the whole Loki instance
Build a table for analytics, usage, or "user did X"	SimpleAgilityObservabilityPlane § The rule that decides where data lives	Some such tables are correct and some are contract violations; the rule tells them apart
Poll a third-party API (search, analytics, anything)	SimpleAgilityObservabilityPlane § Requesting a new feed	Products never poll; the plane captures and ships
Build a ranking, recommendation, or optimization loop	SimpleAgilityFeedbackLoopPattern	Stage ownership plus three mandatory properties that are not optional
Add an alert, a runbook, or an operational action	SimpleAgilityOnCallAutomation	The alert→runbook binding convention and the scoped-surface requirement
Look for a capability the contracts describe	SimpleAgilityRoadmap	Several are not built; this says which, in what order, and what blocks them
Verify a product actually conforms	bin/simple-agility-conformance.sh (Wikantik repo)	Machine-checked, not a prose checklist

Components

Role in the stack	Implemented by	Repository	Status
Observability plane — capture, retention, alerting, source-generic signals	jakemon	~/source/jakemon	Live on docker2
Knowledge and content — agentic wiki; software documentation, support content, SEO content; also the runbook store for on-call	Wikantik	~/source/jspwiki	Live (wiki.wikantik.com, docker1); more than one instance expected
Customer communication — blog/newsletter for proactive customer contact	Roller (Apache Roller 6.2 fork)	see RollerBlogPlatform	In development
Agent runtime — scheduling, ledgers, circuit breakers, blast-radius limits and agent identities for the agents that close the loops (SEO actuator, on-call agent)	not yet built — a stack-level component, deliberately not part of jakemon	—	Planned (roadmap phase 4)

jakemon, Wikantik and Roller are sub-concepts of the Simple Agility domain: each has its own hub for its internals (JakemonHub, WikantikPlatformHub, RollerBlogPlatform), and each of those pages carries a "part of the Simple Agility stack" callout back here. The hierarchy is expressed by links, not by cluster nesting — the existing jakemon, wikantik-development and web-properties clusters stay where they are; a cluster restructure is available later if the company framing solidifies.

The four contracts, plus the backlog

1. SimpleAgilityObservabilityPlane — what the plane owns, what it deliberately does not, the rule that decides where data lives, how products get data out of it (push feeds versus pull queries), how to request a new feed, and its roadmap toward an Operational Data Store (ODS) with Service Level Objective (SLO) / Service Level Agreement (SLA) Key Performance Indicators (KPIs).
2. SimpleAgilityTelemetryContract — how a product gets data into the plane: the /metrics endpoint, the small evolvable log envelope with correlation_id, events-as-log-lines, and the health endpoint. Read this before writing a line of logging in a new product.
3. SimpleAgilityFeedbackLoopPattern — the sense → signal → decide → act → measure loop, who owns each stage, the three properties every product loop must have, Wikantik's Content Intelligence as the worked example, and a Roller sketch.
4. SimpleAgilityOnCallAutomation — how alerts will reach an agent, the alert-to-runbook binding, the escalation ladder (scoped surfaces first; ssh/docker permitted with concurrent human escalation), agent identities, and the agentic interfaces every product must expose.
5. SimpleAgilityRoadmap — what is not built yet, sequenced, with owners, blockers and acceptance tests. The contracts above describe intent; this one describes reality. Consult it before going looking for a capability.

Standing assumptions

• Instanced per tenant. A Simple Agility deployment is the whole stack — its own jakemon, its own Wikantik instance(s), its own Roller — per customer. Inside one deployment, service / instance / site_host labels distinguish products, deployments and web properties. Multi-tenant observability (shared Prometheus/Loki with per-tenant isolation) is not designed and no product should pre-empt it by putting tenant identifiers into its telemetry.
• One tenant may run several instances of one product. Feeds are shipped point-to-point to a named instance; metrics and logs carry an instance label because there the plane is genuinely shared. The two rules pull in opposite directions on purpose — the plane page explains why.
• Signal logic shifts left over time. jakemon currently computes some source-generic SEO signals (visibility/opportunities.py); as products mature that logic tends to move into the product that has the domain context, while the capture stays in the plane.
• Prod is authoritative for content; the wiki is canonical for these documents. They are not mirrored into the Wikantik repository corpus. The Wikantik CLAUDE.md and jakemon CLAUDE.md point here.

See also

• SoftwareProjectsHub — the portfolio these projects sit in
• ContentIntelligenceDesign — the first fully-built Simple Agility feedback loop
• SearchVisibilityExporter — the plane's search-engine capture pipeline