Zero servers.
Full architecture.
The entire Autonomous Author runs inside a browser tab. GitHub Pages delivers the static assets. Groq processes inference. IndexedDB persists sessions. localStorage holds the API key. No backend, no database, no auth server, no cloud compute. This page documents the architecture that makes that possible — and the engineering discipline that keeps it trustworthy.
Every named component —
the reference diagram.
This is the diagram that makes a front-end architect or a technically literate hiring manager stop and read. Every component is named. Every boundary is drawn. Every data flow is typed. Nothing is implicit.
fetch, IndexedDB, and ES6 modules — which is every browser released after 2017.main via GitHub Actions. No domain purchase required — available at username.github.io/autonomous-author. Custom domain can be added at zero cost via GitHub Pages CNAME configuration.rules.json, SHA hash regeneration for prompt-manifest.json, and optionally a lightweight minification step for performance. Build completes in under 30 seconds.IndexedDB API reliability and ES6 module support. Safari's aggressive ITP (Intelligent Tracking Prevention) affects localStorage in some contexts — documented as a known limitation with a session-key fallback.What goes where —
every data boundary mapped.
The privacy model is architectural, not policy-based. "We promise not to store your data" is a policy. "The architecture has no server that could receive your data" is an architectural guarantee. This diagram shows exactly what data flows where, under what conditions, and what never leaves the writer's browser.
From commit to live —
under 90 seconds.
The CI/CD pipeline is deliberately minimal — no Docker, no container registry, no Kubernetes, no managed services. It is a GitHub Actions workflow that validates, hashes, and deploys. The constraint is zero cost and zero operational overhead. Every step is documented below as a named job in the workflow file.
The zero-server security
guarantee — how it holds.
The security model is architectural — not a list of promises. Each item below is a structural property enforced by the implementation, not by a policy document. The zero-server guarantee holds as long as the architecture is intact. Any change that introduces a server-side component breaks the guarantee and requires a documented ADR.
API key stored only in localStorage — never in page source, URL, or request body
The Groq API key is entered by Maya in the Settings panel and written to localStorage. It is read at pipeline init and injected only into the Authorization: Bearer header of Groq API calls. It is never logged, never included in XAI cards, never written to IndexedDB, and never transmitted to any server except Groq's API endpoint.
Content Security Policy blocks all non-Groq external connections
The Content-Security-Policy header served by GitHub Pages enforces: default-src 'self', connect-src https://api.groq.com, script-src 'self'. Any JavaScript attempt to fetch a URL other than the Groq API endpoint is blocked by the browser's CSP enforcement before the request leaves the tab. This is a technical control, not a code-review promise.
HTTPS enforced end-to-end — no mixed content, no HTTP fallback
GitHub Pages enforces HTTPS by default. The Groq API endpoint is HTTPS-only. There is no HTTP fallback in the pipeline code — all fetch calls use the full https:// URL. Mixed content is blocked by the browser. The only unencrypted data is the API key in localStorage — which is protected by the browser's same-origin policy.
Prompt integrity verified via SHA-256 at runtime
On every pipeline init, the orchestrator fetches all prompt files from the GitHub Pages CDN and computes their SHA-256 hashes. These are compared against the expected hashes in prompt-manifest.json. A mismatch — caused by CDN tampering, cache poisoning, or an unauthorised prompt change — prevents the pipeline from starting and surfaces an alert to Maya. Prompts cannot be silently modified in transit.
No eval(), no dynamic script injection, no inline scripts
The CSP script-src 'self' directive blocks eval() and inline script execution. The pipeline code contains no dynamic code evaluation, no document.write(), no innerHTML assignments from API responses. Agent outputs are parsed as JSON and rendered as text — never as HTML or executable code.
IndexedDB access scoped to same origin — no cross-site data leakage
IndexedDB is scoped to the page origin (username.github.io). No other origin can read or write to the TAA IndexedDB store. Session history, drafts, and compliance reports are inaccessible to any other tab, extension, or site. The browser's same-origin policy enforces this without any application-level code.
No third-party analytics, tracking pixels, or telemetry scripts
The page source contains no Google Analytics, no Hotjar, no Sentry, no PostHog, no any third-party script that could transmit browsing behaviour or document metadata. The CSP script-src 'self' would block such scripts even if they were accidentally added. Enterprise IT departments can verify this by inspecting the page source and the CSP headers.
What lives in the browser —
every store, every field.
The three browser storage mechanisms used by the pipeline have distinct responsibilities and lifetimes. This section documents every store, every field, and its retention policy. Nothing is stored without a documented reason and a documented retention period.
Speed targets and
the constraints that bound them.
First contentful paint
Intake to review-ready
With ambiguity detector
1,500-word document
The primary performance constraint is Groq API latency — approximately 1–2 seconds per agent call at 300+ tokens/second. The five-agent P1 pipeline makes 5 sequential API calls; the six-agent P2 pipeline makes 6. At Groq's current free-tier performance, total agent time is 8–12 seconds. Maya's review time (5–8 minutes) dominates the total session time — the pipeline's agent execution is not the bottleneck.
Page load is fast because there is no JavaScript framework to hydrate, no server-side rendering to wait for, and no auth flow to complete. The static HTML/CSS/JS bundle is served directly from GitHub's global CDN. First contentful paint is dominated by the Google Fonts loading — the portfolio page's typography. The app shell (pipeline UI) defers font loading to avoid blocking.
Three infrastructure challenges.
Every objection answered.
"localStorage is accessible to any JavaScript running on the page. An XSS vulnerability — in your code, in a CDN library you load, in a browser extension — would expose the Groq API key. This is textbook credential theft."
Store the key server-side (never in the browser). Accept it at pipeline init, use it for the session, and never persist it. Or use a browser password manager API.
This is a real risk with a real mitigation. The key is AES-256 encrypted before localStorage write, using a device-derived key (Web Crypto API). The CSP blocks all external scripts — the only code that runs is code from the TAA origin, which means XSS from a third-party CDN is blocked structurally. There are no third-party scripts. Browser extensions are outside the threat model — an extension with localStorage access could read anything in any page. The Groq API key is scoped to inference only, not to billing or account management. A stolen key allows someone to make inference calls at Maya's expense — significant but not catastrophic. This risk is disclosed in the Settings UI.
A server-side key store would eliminate this risk but would require a backend — violating AR-03 and the zero-server guarantee. The architecture trades a mitigated credential-theft risk for an absolute data-sovereignty guarantee. For an enterprise writer, the data guarantee is worth more than the credential risk.
"GitHub Pages is a free service with no uptime SLA. GitHub has had outages. An enterprise writer depending on this tool for sprint deliverables will be blocked if GitHub is down."
Host on a paid service with an SLA — Vercel, Netlify, or Cloudflare Pages — all have free tiers with better uptime guarantees and CDN redundancy than GitHub Pages.
GitHub Pages has a documented 99.9% uptime track record despite lacking a formal SLA. More importantly: this is a portfolio tool used by an individual writer, not a production service with contractual obligations. The risk of a GitHub outage during a sprint document session is real but low-frequency and low-duration. The mitigation is the browser cache — prompt files and rules.json are cached after first load, so the pipeline can continue running offline for an active session even if the CDN goes down. A full outage would prevent loading the page for the first time, not interrupt an active session.
No formal SLA. GitHub outages would block new page loads. For a portfolio demonstration tool used by one writer, this is acceptable. If this tool were adopted at enterprise scale, migrating to Cloudflare Pages (still free) would provide better global CDN performance and more resilient delivery with zero code changes.
"Your agents execute sequentially. If the Draft Agent call takes 8 seconds instead of 4, the total pipeline time blows past the 15-minute target. Groq's free tier has variable latency."
Parallelize agents where possible — run Compliance Agent and Ambiguity Detector concurrently since they both consume the DraftDocument. Saves 2 seconds on P2.
Agents are sequential by design — ADR-005 (LangGraph-pattern over AutoGPT loops). The XAI layer depends on agents executing in order so reasoning cards stream into the pipeline monitor in sequence. Maya watches the pipeline run — the sequential execution is not just an architecture choice, it is the UX. Parallelising Compliance and Ambiguity would cause both cards to appear simultaneously, breaking the sequential reasoning narrative. The 15-minute target includes headroom for Groq latency variation — p95 is 14.2 seconds at current performance. If Groq latency degrades consistently, that is a drift signal (Source 1 in the drift taxonomy) that triggers the model upgrade protocol evaluation.
Sequential execution means total pipeline time is the sum of all agent latencies. Parallelisation would reduce this by ~2 seconds on P2. The UX value of sequential XAI card streaming outweighs the 2-second saving. The pipeline monitor's real-time card display is the primary XAI interface — destroying it for marginal performance gain is the wrong trade-off.