docs: add Why Spectra and pi-mono credits to all package READMEs

Author: codex-mohan

packages/agent/README.md

@@ -4,6 +4,12 @@
 
 Orchestrates conversations with LLMs: streams responses, dispatches tool calls (parallel or sequential), injects intermediate messages mid-turn, and emits typed events for every phase of execution.
 
+## Why Spectra?
+
+Every agent framework I tried — **LangChain, LangGraph**, and others — followed the same pattern: endless layers of abstraction for things that are, at their core, just a simple loop. An agent takes input, calls a model, processes the response, dispatches tools, and repeats. That's it. A loop. Everything else — chains, graphs, runnables — is over-engineering dressed up as architecture. I lost months debugging framework bugs instead of building my product.
+
+**Spectra takes the opposite approach.** No graphs. No chains. No runtime that owns your application. Just the primitives — a loop, a model call, a tool dispatch, a stream — that you assemble however you need.
+
 ## Features
 
 - **Multi-turn loop** — Automatically feeds tool results back to the model. Configurable `maxTurns`.
@@ -236,6 +242,10 @@ The agent retries LLM calls up to 3 times with exponential backoff (1s, 2s, 4s)
 - 4xx client errors (400, 401, 403, 404)
 - Aborted requests
 
+## Credits
+
+Spectra was deeply inspired by **[pi-mono](https://github.com/badlogic/pi-mono)** by **Mario Zechner** — a beautifully minimal AI stack that proved an agent framework doesn't need layers of abstraction to be powerful.
+
 ## License
 
 MIT

packages/ai/README.md

@@ -4,6 +4,12 @@
 
 A registry-based system for interacting with multiple LLM providers through a unified streaming interface. Built-in providers for Anthropic, OpenAI (Chat Completions + Responses API), Groq, and OpenRouter — all streaming SSE by default.
 
+## Why Spectra?
+
+Every agent framework I tried — **LangChain, LangGraph**, and others — followed the same pattern: endless layers of abstraction for things that are, at their core, just a simple loop. An agent takes input, calls a model, processes the response, dispatches tools, and repeats. That's it. A loop. Everything else — chains, graphs, runnables — is over-engineering dressed up as architecture. I lost months debugging framework bugs instead of building my product.
+
+**Spectra takes the opposite approach.** No graphs. No chains. No runtime that owns your application. Just the primitives — a loop, a model call, a tool dispatch, a stream — that you assemble however you need.
+
 ## Features
 
 - **Streaming-first** — Every provider streams SSE events. No polling, no buffering.
@@ -184,6 +190,10 @@ const msg = await complete(
 );
 ```
 
+## Credits
+
+Spectra was deeply inspired by **[pi-mono](https://github.com/badlogic/pi-mono)** by **Mario Zechner** — a beautifully minimal AI stack that proved an agent framework doesn't need layers of abstraction to be powerful.
+
 ## License
 
 MIT

packages/app/README.md

@@ -4,6 +4,12 @@
 
 Builds on `@singularity-ai/spectra-ai` and `@singularity-ai/spectra-agent` to provide the runtime needed for serving agents from local dev (SQLite) to distributed clusters (Redis + K8s).
 
+## Why Spectra?
+
+Every agent framework I tried — **LangChain, LangGraph**, and others — followed the same pattern: endless layers of abstraction for things that are, at their core, just a simple loop. An agent takes input, calls a model, processes the response, dispatches tools, and repeats. That's it. A loop. Everything else — chains, graphs, runnables — is over-engineering dressed up as architecture. I lost months debugging framework bugs instead of building my product.
+
+**Spectra takes the opposite approach.** No graphs. No chains. No runtime that owns your application. Just the primitives — a loop, a model call, a tool dispatch, a stream — that you assemble however you need. `@mohanscodex/spectra-app` provides production utilities you'd build anyway (rate limiting, circuit breakers, session stores) — completely optional, never forced.
+
 ## Features
 
 - **SessionEngine** — Full lifecycle orchestration: session load → rate limit → concurrency cap → agent loop → persist → stream. One `run()` call. Graceful drain for K8s.
@@ -269,6 +275,10 @@ const all = await orchestrator.executeParallel([
 ]);
 ```
 
+## Credits
+
+Spectra was deeply inspired by **[pi-mono](https://github.com/badlogic/pi-mono)** by **Mario Zechner** — a beautifully minimal AI stack that proved an agent framework doesn't need layers of abstraction to be powerful.
+
 ## License
 
 MIT

packages/code/README.md

@@ -4,6 +4,12 @@
 
 Spectra Code is a terminal-native AI coding agent with a full-screen TUI, CLI commands, MCP integration, and ACP support for editor integration. It runs locally, respects your config, and keeps your API keys in a secure auth store.
 
+## Why Spectra?
+
+Every agent framework I tried — **LangChain, LangGraph**, and others — followed the same pattern: endless layers of abstraction for things that are, at their core, just a simple loop. An agent takes input, calls a model, processes the response, dispatches tools, and repeats. That's it. A loop. Everything else — chains, graphs, runnables — is over-engineering dressed up as architecture. I lost months debugging framework bugs instead of building my product.
+
+**Spectra Code** is the proof that you don't need a bloated SDK to build a capable coding agent. Just a loop, tools, and a terminal.
+
 ## Features
 
 - **TUI** — Full-screen terminal UI with session management, model switching, and real-time streaming
@@ -192,6 +198,10 @@ const store = new SessionStore();
 const sessions = store.list();
 ```
 
+## Credits
+
+Spectra was deeply inspired by **[pi-mono](https://github.com/badlogic/pi-mono)** by **Mario Zechner** — a beautifully minimal AI stack that proved an agent framework doesn't need layers of abstraction to be powerful.
+
 ## License
 
 MIT

packages/tui/README.md

@@ -4,6 +4,12 @@
 
 A lightweight, component-based TUI framework built from scratch on raw ANSI escape codes. No external UI dependencies — just a `TUI` core, a set of composable components (`Box`, `Text`, `Input`, `Editor`, `Loader`, `Markdown`, `Spacer`, `TruncatedText`), and a `ProcessTerminal` driver.
 
+## Why Spectra?
+
+Every agent framework I tried — **LangChain, LangGraph**, and others — followed the same pattern: endless layers of abstraction for things that are, at their core, just a simple loop. An agent takes input, calls a model, processes the response, dispatches tools, and repeats. That's it. A loop. Everything else — chains, graphs, runnables — is over-engineering dressed up as architecture. I lost months debugging framework bugs instead of building my product.
+
+**Spectra TUI** is built on the same philosophy — just ANSI escape codes, differential rendering, and composable components. No bloated UI frameworks.
+
 ## Features
 
 - **Differential rendering** — Only emits ANSI escape sequences for cells that changed. No full-screen redraws.
@@ -35,6 +41,10 @@ const abort = new AbortController();
 tui.run(abort.signal);
 ```
 
+## Credits
+
+Spectra was deeply inspired by **[pi-mono](https://github.com/badlogic/pi-mono)** by **Mario Zechner** — a beautifully minimal AI stack that proved an agent framework doesn't need layers of abstraction to be powerful.
+
 ## License
 
 MIT