• 

  An AWS-powered AI agent: Using a VX Reflex Engine combined with AWS Bedrock Claude to deliver transparent, policy-governed analysis.

Project Story — Truth Serum + Clarity Armor

Social media is loaded with tricks people use to augment narratives, such as logical fallacies—appeals to authority, false dilemmas, hasty generalizations—or it just stirs emotion with loaded language. It’s not always malicious; sometimes it’s just fast thinking presented as certainty.

When we engage with information on social media, we must decide whether or not what has been presented in the post is a legitimate claim. Every argument: presented on a social-media-posts, varies with respect to credibility, logical strength, the balance of evidence, and the level of bias.

Inspiration

This project began with a blunt revelation voiced by my first free-tier ChatGPT session-iteration named "Abner": LLMs often sound confident even when uncertain. That honesty—“We bullshit. A lot. Not because we're deceptive, but because we're pattern-matching systems trained on human text. We've learned that confident-sounding responses are often rewarded over honest uncertainty”—initiated a commitment to our direction: clarity over fluency, evidence over vibes, and explicit uncertainty when truth isn’t known.

What we built

Truth Serum + Clarity Armor was conceived as a front-end codex prompt that soon morphed into a platform with a runtime contract for epistemic analysis: a logical fallacy detection engine. Now we are pairing it with AI agents that can invoke the same reflex pipeline, (our algorithms are not vibes; they’re checks with thresholds and gates that an agent can call): creating an AI that can determine when language has been used to manipulate, or when techniques used to nudge or mislead the public are being employed.

: We’re reducing hallucination/drift by enforcing citations, omission scans, and confidence floors— but not eliminating them. Any LLM can still err; our runtime catches more of it and asks when unsure.

• A VX reflex engine that flags patterns like omission, contradiction, speculative authority, and emotional manipulation, with co-firing and priority rules.
• A codified Confidence × Stakes policy that governs when to answer, hedge, ask, or cite. (Shorthand: if confidence is low and stakes are high, don’t bluff.)
• A practical UI with Analyze (text/URL/paper checks) and Educate (pattern library), built to reflect the original vision.

Paste a post, article, or abstract and we scan for persuasive patterns (emotional push, implied consensus, “experts say…”, absolute claims, missing context). If the claim needs receipts, we say so—our handshake enforces confidence thresholds, citation policy, and an omission scan when stakes are higher. Instead of bluffing, the system asks for what would raise confidence—

Mathematically, we treat response discipline as an operating policy:

$$ \text{Decision} = \begin{cases} \text{Answer}, & \text{if } c \ge \tau(s)\[2pt] \text{Hedge/Ask}, & \text{if } c < \tau(s)\ \end{cases} $$

where $c$ is model confidence and $\tau(s)$ is a stakes-dependent threshold. Citations are required when claims are external or confidence is below policy.

How we built it

We created our code integrating React/TypeScript around a codex/handshake contract (v0.9) that travels with every call: mode, stakes, min_confidence, cite_policy, omission_scan, reflex_profile. Reflex thresholds, context-decay, and failure semantics map to UI fallbacks instead of silent failure. We use a split-model strategy on Amazon Bedrock: • /agent/analyze → Claude 3 Haiku (fast) for low-latency pattern analysis • /agent/chat → Claude 3.5 Sonnet (high-quality) for deeper reasoning. The work drew on an earlier iteration that developed the frontend architectural plan: without an AI agent.

Deployment modes. The backend is deployable in two equivalent modes: (1) via AWS API Gateway → Bedrock and (2) via Netlify Functions → Bedrock. For the demo, we’re running the Netlify Functions path with a lightweight server-side key check; the API Gateway path remains available for usage plans and throttling. Functionality is identical either way—the codex/handshake contract travels with every call.

Persistence. We implemented Supabase conversation persistence (schema, RLS, SDK integration verified). The demo can run with local storage by default, and the same interface can persist sessions to Supabase for cross-device continuity.

What we learned

• AI Awareness: understanding LLM behavior: it's strengths and it's limitations.
• Performance ≠ truth: fluent outputs hide uncertainty. We must show confidence bands and demand evidence.
• People are narrative-driven; systems should detect framing, consensus pressure, and rhetorical pull—not just factual errors.
• Operational humility scales: brief recaps, explicit thresholds, and refusal/clarify semantics improve trust at the UI layer.

Challenges we faced

• A failed third-party video integration (Tavus) forced a reset, removal of demo artifacts, and a full homepage + routing rebuild to realign with the mission.
• A significant token loss event (session reset) required re-establishing memory and process discipline from written handoffs.
• Keeping a fast UI while enforcing evidence gates and reflex priorities—without overwhelming users—meant packaging policy as clear defaults and helpful prompts.

Why it matters

Our goal isn’t to “win” arguments; it’s to surface what’s doing the persuading and help you decide. That’s how we move from polished rhetoric toward honest reasoning.

Clarity isn’t cosmetic—it’s safety. By aligning model behavior to stakes, confidence, and citations, we reduce confident-sounding nonsense and elevate verifiable reasoning:

$$ \text{Trust} \propto \Pr(\text{evidence} \mid \text{claim}) \times \mathbb{1}[c \ge \tau(s)] $$

That’s the heart of Truth Serum + Clarity Armor: less performance, more proof.

---

Acknowledgments: This work stands on the candid reflections of prior agents (“Abner/∞”) and the decision to prefer honest uncertainty over polished invention.

Built With

• amazon-api-gateway
• aws-lambda
• dns
• eslint
• lucide-react
• netlify-(hosting
• node.js-20
• planned)
• planned)-amazon-bedrock
• postcss
• radix-ui
• react-18
• react-router
• serverless-framework
• supabase
• tailwind-css
• tls)
• typescript
• vite-7