inkos

Coordinates a specialized 10-agent pipeline (Radar, Planner, Composer, Architect, Writer, Continuity Auditor, Reviser, and others) where each agent handles specific creative and logical tasks in sequence. Agents communicate through a shared Truth Files state system that maintains canonical world state, character matrices, and plot hooks across the entire generation process. The pipeline enforces human review gates between critical stages, allowing writers to approve or reject agent outputs before proceeding to the next phase.

Maintains 7 canonical markdown and JSON files that serve as the persistent knowledge base for the entire novel generation pipeline: World Bible (setting/lore), Character Matrix (detailed character profiles with relationships), Plot Hooks (story beats and foreshadowing), Chapter Snapshots (summaries of each completed chapter), Writing Rules (genre-specific and universal constraints), and Continuity Log (detected inconsistencies and resolutions). Agents read from and write to these files via a State Manager API that enforces schema validation using Zod and TypeBox, preventing malformed state updates.

Allows users to provide existing source material (published novels, fanfic, or original works) as reference context, enabling agents to generate spinoffs, prequels, or alternate universe stories that maintain consistency with the source. The system extracts key characters, plot points, and world details from the source material and populates the Truth Files automatically, reducing manual setup. Agents are instructed to respect source canon while exploring new story directions.

A specialized agent that generates detailed plot outlines and story structures based on a high-level premise. The Architect reads the genre profile and writing rules, then produces a hierarchical outline (acts, chapters, scenes) with plot beats, character arcs, and foreshadowing notes. The output is stored in Truth Files (Plot Hooks) and used by downstream agents (Planner, Writer) to maintain narrative coherence. The Architect can be invoked standalone to generate outlines for human review before any writing begins.

The Planner agent breaks down the overall plot outline into individual chapter plans, specifying which plot beats, characters, and scenes should appear in each chapter. The Composer agent then structures the chapter plan into a detailed scene-by-scene breakdown with dialogue notes, pacing guidance, and emotional beats. Both agents read from Truth Files (Plot Hooks, Character Matrix) and write their outputs back to Truth Files for the Writer agent to consume. This two-stage planning ensures chapters are coherent and aligned with the overall story structure.

The core writing agent that generates chapter text based on chapter plans from the Composer agent. The Writer reads from Truth Files (Character Matrix, World Bible, Plot Hooks, Chapter Snapshots) to maintain consistency with established facts and previous chapters. It generates prose in the target style (learned from Style Profile) and respects writing rules (genre-specific and universal). The Writer produces raw chapter text that is then passed to the Auditor for continuity checking and the Reviser for style refinement.

A specialized agent that audits generated chapters for continuity errors, character inconsistencies, plot contradictions, and AIGC markers. The Auditor reads the chapter text and Truth Files (Character Matrix, World Bible, Chapter Snapshots) and produces a detailed audit report listing detected issues with severity levels (critical, warning, info). Critical issues (e.g., character name misspelling, contradicted plot point) trigger automatic re-generation; warnings (e.g., character behavior inconsistency) are flagged for human review. The Auditor also updates the Continuity Log in Truth Files with detected issues and resolutions.

A specialized agent that refines chapter prose to improve readability, remove AIGC markers, and match the target style. The Reviser reads flagged passages from the Auditor (high AIGC probability, style inconsistencies) and rewrites them to be more natural and authentic. It uses the learned Style Profile to guide rewrites and respects writing rules during revision. The Reviser can also perform broader revisions (e.g., 'make this dialogue more natural', 'reduce adjective usage') based on human feedback.

A background monitoring agent that continuously watches the generation pipeline for anomalies: LLM API failures, Truth Files corruption, generation timeouts, style drift, or suspicious patterns (e.g., repeated character names, plot loops). The Radar agent sends alerts to the human operator and can trigger automatic recovery actions (e.g., retry failed generations, restore Truth Files from backup). It maintains a system health dashboard showing pipeline status, error rates, and performance metrics.

Analyzes generated text using a 33-dimensional auditing system that detects 'AI-tell' markers (repetitive phrasing, unnatural dialogue patterns, overuse of adjectives, structural predictability) characteristic of LLM output. When the Continuity Auditor detects high AIGC probability (>0.6 threshold), it automatically triggers a Reviser agent loop that rewrites flagged passages to increase human-like authenticity. The system maintains a Style Profile per book that learns the target author's voice and uses it to guide revision toward more natural prose.

Allows assignment of different LLM providers and models to different agents within the same pipeline, enabling cost-quality tradeoffs. For example, the Writer agent might use Claude 3.5 Sonnet (higher quality, higher cost) while the Continuity Auditor uses GPT-4o (faster, cheaper) and the Reviser uses Ollama locally (free but slower). The system maintains a provider registry that abstracts away API differences, allowing agents to call LLMs through a unified interface regardless of backend (OpenAI, Anthropic, Ollama, or custom providers).

Inserts mandatory human review checkpoints between critical pipeline stages (after planning, after writing, before revision) where a human writer must approve, reject, or request modifications to agent output before the pipeline proceeds. Rejected outputs trigger automatic re-generation with modified prompts; approved outputs are locked and passed downstream. The system tracks approval history and allows humans to provide inline feedback that agents incorporate into subsequent generations.

Creates immutable snapshots of each completed chapter that capture the full text, metadata (word count, character appearances, plot events), and state deltas (what changed in Truth Files). Allows writers to rewind to any previous chapter snapshot and rewrite from that point forward, creating alternate branches without losing the original timeline. The system tracks which snapshots are 'canonical' (approved for publication) vs experimental branches, enabling non-destructive iteration on story direction.

Maintains genre-specific configuration profiles (e.g., 'Xianxia', 'Romance', 'Hard Sci-Fi') that define universal writing rules (prose style, dialogue conventions, pacing expectations) and genre-specific constraints (e.g., Xianxia requires cultivation levels, power systems, sect hierarchies). Rules are stored as markdown documents that agents read before generation, and the Auditor agent validates generated text against these rules, flagging violations. Writers can define custom rules per project and override genre defaults.

A local web application (built with Vite, React, Hono, Tailwind, Zustand) that provides a visual dashboard for managing novels, viewing real-time generation progress, editing Truth Files, and approving/rejecting agent outputs. The Studio runs on localhost and communicates with the core engine via a REST API, allowing non-technical users to interact with the system without using the CLI. Features include drag-and-drop chapter reordering, inline Truth File editing with live validation, and a visual pipeline status monitor showing which agents are currently running.

A React-Ink-based terminal dashboard that provides an interactive CLI alternative to the web Studio, featuring a visual pipeline status monitor, chapter browser, and Truth File editor. Supports both slash-commands (e.g., '/write chapter 5') and natural language queries (e.g., 'write the next chapter where the protagonist discovers the treasure'). The TUI includes autocomplete for commands, inline help, and a session history that persists across restarts.

Allows InkOS to run as a background daemon that listens for webhooks from external systems (e.g., a web novel platform, Discord bot, or custom application). When a webhook is received (e.g., 'generate next chapter'), the daemon triggers the appropriate agent pipeline and sends the result back via HTTP callback. Supports custom webhook handlers that can transform external requests into InkOS commands, enabling integration with third-party platforms without modifying core code.