docs: Update marketing posts for v2.3.0 and ignore drafts

- Update LINKEDIN_POST.md with v2.3 features (ModelRouter, 80% savings)
- Update SHOW_HN_POST.md with v2.3 messaging
- Add docs/marketing/drafts/ to .gitignore (keep internal content local)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: 2 people

.gitignore

@@ -129,3 +129,6 @@ patterns/tech_debt_demo/
 
 # Consolidated wizards (working directory)
 wizards_consolidated/
+
+# Marketing drafts (internal only)
+docs/marketing/drafts/

docs/marketing/LINKEDIN_POST.md

@@ -1,103 +1,41 @@
-# LinkedIn Announcement: Empathy Framework
+# LinkedIn Announcement: Empathy Framework v2.3
 
-## The AI collaboration framework that predicts problems before they happen
+## Just shipped: AI that remembers you AND costs 80% less
 
-Today's AI tools are brilliant but broken for enterprise use.
+Every AI conversation starts from scratch. Preferences forgotten. Context lost.
 
-They're **stateless** — forgetting everything between sessions.
-They're **cloud-dependent** — your proprietary code leaves your infrastructure.
-They're **isolated** — unable to coordinate with other agents or teams.
-They're **reactive** — waiting for problems instead of preventing them.
-They're **expensive** — every query costs the same, regardless of complexity.
+And you're paying Opus prices ($15/M tokens) for tasks Haiku could handle ($0.25/M).
 
-I built the Empathy Framework to solve all five.
+I built Empathy Framework to fix both. v2.3 just shipped.
 
 ---
 
-### What Makes Empathy Different
+**What's new:**
 
-**Memory That Persists**
-Dual-layer architecture: git-based pattern storage for long-term knowledge (version-controlled, no infrastructure required), optional Redis for real-time multi-agent coordination. What one agent learns today informs decisions tomorrow. Works anywhere — students use just git, enterprises add Redis for team coordination.
+**1. Smart Model Routing (80% savings)**
+Auto-picks Haiku/Sonnet/Opus based on task complexity.
+Real numbers: $4.05/task → $0.83/task
 
-**Enterprise-Ready**
-Your data stays local. Nothing leaves your infrastructure. Built-in compliance patterns for HIPAA, GDPR, and SOC2. Full audit trail — every action logged, exportable, searchable.
+**2. Persistent Memory**
+Preferences survive across sessions. Bug patterns accumulate. Your AI actually learns.
 
-**Anticipatory Intelligence**
-Predicts issues 30-90 days ahead. Security vulnerabilities, performance degradation, compliance gaps — caught before they become urgent. Prevention over reaction.
-
-**Multi-Agent Orchestration**
-Empathy OS manages human↔AI and AI↔AI collaboration. Specialized agents working in concert with trust management, feedback loops, and conflict resolution when agents disagree.
-
-**Performance & Cost**
-Smart model routing: detection models triage, capable models decide. Plus persistent memory eliminates repeated context — no more wasting tokens re-explaining what your AI should already know. Sub-millisecond coordination between agents.
-
-**Code Health Assistant** *(New in v2.2)*
-One command runs lint, format, type checks, tests, security, and dependency audits. Auto-fix safe issues. Track health scores over time. Find hotspots before they become problems.
-
-```bash
-empathy health              # Quick check
-empathy health --deep       # Full analysis
-empathy health --fix        # Auto-fix issues
-```
+**3. Claude Code Integration**
+`empathy sync-claude` syncs patterns to `.claude/rules/` — Claude Code loads your team's history at session start.
 
 ---
 
-### For Builders
-
-30+ production wizards included: security, performance, testing, documentation, accessibility, compliance.
-
-Agent toolkit to build custom agents that inherit memory, trust, and anticipatory capabilities.
-
-5-level progression built in — your agents evolve from reactive to anticipatory automatically.
+**Quick start:**
 
----
-
-### Quick Start
-
-```bash
+```
 pip install empathy-framework
-empathy-memory serve
 ```
 
-Two commands. For full features, Redis auto-starts. Long-term pattern storage requires zero infrastructure — it's git-based and lives in your repo.
-
 ---
 
-### Pricing
-
-| Tier | Price | Includes |
-|------|-------|----------|
-| **Free** | $0 | Students, educators, teams ≤5 employees |
-| **Commercial** | $99/dev/year | Full framework, priority support |
-| **Enterprise** | Contact us | Custom deployment, SLA, training |
-
-Fair Source 0.9 licensed — auto-converts to Apache 2.0 on January 1, 2029.
-
----
-
-### Use Case: AI Nurse Florence
-
-We built Florence, a healthcare assistant, on Empathy Framework:
-- HIPAA-compliant memory with encrypted pattern storage
-- Clinical protocol support (SBAR, SOAP notes)
-- Enterprise-grade privacy controls
-
-It demonstrates what's possible when AI has persistent memory and compliance built in.
-
----
-
-### Get Started
-
-**Install:** `pip install empathy-framework`
-
-**GitHub:** https://github.com/Smart-AI-Memory/empathy
-
-**Contact:** [email protected]
-
-I'd welcome your feedback on the approach. What would make this useful for your team?
-
----
+**Links:**
+- GitHub: github.com/Smart-AI-Memory/empathy-framework
+- Live Demo: empathy-framework.vercel.app/tools/debug-wizard
 
-*Built by [Smart AI Memory](https://smartaimemory.com)*
+What would you build with an AI that remembers—and costs 80% less?
 
-#AI #DevOps #EnterpriseAI #ArtificialIntelligence #SoftwareEngineering #MachineLearning #AIOrchestration #DeveloperTools #OpenSource
+#AI #Python #Claude #DevTools #CostOptimization

docs/marketing/SHOW_HN_POST.md

@@ -1,75 +1,91 @@
-# Show HN: Empathy Framework – AI collaboration with persistent memory
+# Show HN: Empathy Framework v2.3 – Persistent AI memory + 80% cost savings
 
-**Title:** Empathy Framework – AI collaboration with persistent memory and multi-agent orchestration
+**Title:** Empathy Framework v2.3 – Persistent AI memory + smart model routing (80% cost savings)
 
-**URL:** https://github.com/Smart-AI-Memory/empathy
+**URL:** https://github.com/Smart-AI-Memory/empathy-framework
 
 ---
 
-I've been building AI tools for healthcare and software development. The biggest frustration? Every AI session starts from zero. No memory of what you worked on yesterday, no patterns learned across projects, no coordination between agents.
+I've been building AI tools and got tired of two problems: every session starts from zero, and I was paying Opus prices for simple tasks.
 
-So I built the Empathy Framework.
+So I built Empathy Framework. v2.3 just shipped with major cost optimization.
 
-**The five problems it solves:**
+**The 80% cost savings:**
 
-1. **Stateless** — AI forgets everything between sessions. Empathy has dual-layer memory: git-based pattern storage for long-term knowledge (no infrastructure required), optional Redis for real-time coordination.
+New ModelRouter automatically picks the right model tier:
 
-2. **Cloud-dependent** — Your code goes to someone else's servers. Empathy runs entirely local-first. Memory lives in your repo, version-controlled like code.
+```python
+from empathy_llm_toolkit import EmpathyLLM
+
+llm = EmpathyLLM(provider="anthropic", enable_model_routing=True)
+
+# Summaries → Haiku ($0.25/M tokens)
+# Code gen → Sonnet ($3/M tokens)
+# Architecture → Opus ($15/M tokens)
+```
+
+Real numbers: $4.05/task → $0.83/task. That's 80% savings by just using the right model for each task.
 
-3. **Isolated** — AI tools can't coordinate. Empathy has built-in multi-agent orchestration (Empathy OS) for human↔AI and AI↔AI collaboration.
+**The memory problem:**
 
-4. **Reactive** — AI waits for you to find problems. Empathy predicts issues 30-90 days ahead using pattern analysis.
+AI forgets everything between sessions. Tell it you prefer type hints? Gone next time. Empathy adds persistent memory:
+
+```python
+llm = EmpathyLLM(provider="anthropic", memory_enabled=True)
+
+await llm.interact(
+    user_id="me",
+    user_input="I prefer Python with type hints"
+)
+# Survives across sessions
+```
 
-5. **Expensive** — Every query costs the same, and you waste tokens re-explaining context. Empathy routes smartly (cheap models detect, capable models decide) AND eliminates repeated context — no more re-teaching your AI what it should already know.
+**New in v2.3:**
+
+1. **ModelRouter** — Automatic Haiku/Sonnet/Opus selection based on task complexity
+2. **`empathy sync-claude`** — Sync learned patterns to Claude Code's `.claude/rules/` directory
+3. **Debug Wizard** — Web UI at empathy-framework.vercel.app/tools/debug-wizard that remembers past bugs
+
+**How the memory works:**
+
+- Git-based pattern storage (no infrastructure needed)
+- Optional Redis for real-time coordination
+- Bug patterns, security decisions, coding preferences all persist
 
 **What's included:**
 
-- **Code Health Assistant** (`empathy health`) — lint, format, types, tests, security in one command with auto-fix
-- **Pattern-based code review** (`empathy review`) — catches bugs before they happen based on your team's history
-- Memory Control Panel CLI (`empathy-memory serve`) and REST API
-- 30+ production wizards (security, performance, testing, docs, accessibility)
-- Agent toolkit to build custom agents that inherit memory and prediction
-- Healthcare suite with HIPAA-compliant patterns (SBAR, SOAP notes)
-- Works with Claude, GPT-4, Ollama, or your own models
+- `empathy-inspect` — unified code inspection (lint, security, tests, tech debt)
+- SARIF output for GitHub/GitLab code scanning
+- HTML dashboard reports
+- 30+ production wizards (security, performance, testing, docs)
+- Works with Claude, GPT-4, or Ollama
 
 **Quick start:**
 
 ```bash
 pip install empathy-framework
-empathy health              # Check code health
-empathy health --fix        # Auto-fix safe issues
-empathy-memory serve        # Start memory server
 ```
 
-That's it. Redis auto-starts for real-time features, but long-term pattern storage works with just git — no infrastructure needed for students and individual developers.
-
-**Example:**
-
 ```python
-from empathy_os import EmpathyOS
-
-os = EmpathyOS()
-
-result = await os.collaborate(
-    "Review this deployment pipeline for problems",
-    context={"code": pipeline_code}
+llm = EmpathyLLM(
+    provider="anthropic",
+    memory_enabled=True,
+    enable_model_routing=True
 )
 
-print(result.current_issues)      # What's wrong now
-print(result.predicted_issues)    # What will break in 30-90 days
-print(result.prevention_steps)    # How to prevent it
+await llm.interact(user_id="dev", user_input="Review this code")
 ```
 
-**Licensing:**
-
-Fair Source 0.9 — Free for students, educators, and teams ≤5 employees. Commercial license $99/dev/year. Auto-converts to Apache 2.0 on January 1, 2029.
+**Licensing:** Fair Source 0.9 — Free for students and teams ≤5. $99/dev/year commercial. Auto-converts to Apache 2.0 on Jan 1, 2029.
 
 **What I'm looking for:**
 
-- Feedback on the memory architecture (git-based patterns + optional Redis)
-- Ideas for cross-domain pattern transfer (healthcare insights → software)
-- Integration suggestions (CI/CD, IDE, pre-commit hooks?)
+- Feedback on the model routing approach
+- Ideas for other cost optimizations
+- Integration suggestions (CI/CD, pre-commit hooks?)
+
+GitHub: https://github.com/Smart-AI-Memory/empathy-framework
 
-GitHub: https://github.com/Smart-AI-Memory/empathy
+Live demo: https://empathy-framework.vercel.app/tools/debug-wizard
 
-Happy to answer questions about the architecture or use cases.
+Happy to answer questions.