Jixu
Durable single-Agent Harness for TypeScript: recoverable Threads, context continuity, explicit side effects, and a native TUI.
What is it?
What it is
A small single-Agent harness for TypeScript that defines one Agent with Tools and Skills and continues its work in a durable Thread.
Why it exists
Agent loops are easy to start but hard to resume safely; Jixu records work as ordered Events so a Thread can recover, Replay, Fork, or continue later.
Who should use it
Developers building single-agent AI systems who need durable, recoverable agent workflows with persistent state and the ability to resume interrupted work.
Who should avoid it
Teams requiring multi-agent orchestration, complex workflow management, or guaranteed exactly-once execution across distributed systems. Not suitable for applications needing sophisticated scheduling or multi-agent collaboration.
Stars over time
No change stars in the last 1 day
How it works
A quick walkthrough in plain English
How Jixu works
Step 1 of 3
You interact with it
Open Jixu, send a request, or connect it to your stack.
Features
Advantages
- Minimal, focused API surface
- Durable execution enables safe work resumption
- Immutable events allow reliable replay without live API calls
- No separate workflow engine or orchestration runtime
- Deterministic state derived from ordered events
- External work recorded before dispatch for recovery
- Thread can recover, replay, fork, or continue later
- Context window managed without guessing (fails if unknown)
- Events are never rewritten, preserving history
- Plan coordination without dispatch capability
- Secrets never enter Events, State, Checkpoints, or Signals
- Multiple storage options for different use cases
- Operator decisions are durable context, not invented results
- Supports standard and ultra reasoning modes
Disadvantages
- Pre-1.0 status with potential API breaking changes
- Single-Agent only, not a multi-agent orchestrator
- Bash Tool is not OS-sandboxed and runs with process permissions
- Intel macOS not supported for native TUI
- Requires Node.js 22.19.0 minimum
- No generic exactly-once execution guarantee
- Not a workflow engine or hosted control plane
- No Agent graphs, supervisors, queues, or schedulers
- Permission controls approve Tool calls, not individual shell operations
- May need backup or disposable workspace for Bash Tool use
Installation
native
npm install -g jixu-ai\njixu\n\nGlobal installation also works with `pnpm add -g jixu-ai` and `bun add -g jixu-ai`. Or run Jixu without installing it:\n\n```bash\nnpx jixu-ai\n# pnpm dlx jixu-ai\n# yarn dlx jixu-ai\n# bunx jixu-ai\n```\n\nThe package launcher requires Node.js 22.19.0 or newer. The native TUI supports macOS arm64 and Linux x64 with glibc; Intel macOS is not supported. Bun is not required at runtime.
FAQ
How do I install Jixu and launch the reference TUI?
Jixu can be installed globally via npm install -g jixu-ai, pnpm add -g jixu-ai, or bun add -g jixu-ai. Alternatively, run it without installation using npx jixu-ai, pnpm dlx jixu-ai, yarn dlx jixu-ai, or bunx jixu-ai. The launcher requires Node.js 22.19.0 or newer, and the native TUI supports macOS arm64 and Linux x64 with glibc.
What does thread.send() do and how does it handle input during execution?
thread.send() durably accepts ordered text and image input. Any input received while a turn is running is queued in Event order, ensuring the Thread maintains a coherent, durable execution history that can recover, replay, or fork from any point.
How does Jixu enable thread recovery and replay without calling a live model or tool?
Jixu records execution as ordered Events. State is derived purely from these Events via a deterministic reducer. Replay rebuilds State from recorded Events with zero live driver calls, never invoking a live model or tool, which allows safe recovery, Replay, or Fork operations from any point in the Thread's history.
What does it mean that the Agent definition is immutable, and how does it relate to Threads?
Each Harness has one immutable Agent definition. Threads hold that Agent's durable history, meaning the Agent's instructions, model, and tool schemas are fixed at creation, while Threads accumulate the mutable, durable event history that can be replayed or forked independently.
How does Jixu assemble model requests using context engineering?
Jixu constructs model requests from the Thread's durable material, including Agent instructions, relevant Events, the active Plan, Skills, Tool schemas, Artifacts, and recent work. A redacted Context Manifest records what was selected and why. If capacity is unknown, Jixu stops instead of guessing, and older work can be compacted into a Continuity Handoff while retaining a bounded tail of complete operations.
What kind of system is Jixu not, and what guarantees does it not provide?
Jixu is not a multi-agent orchestrator, workflow engine, or hosted control plane. It does not add Agent graphs, supervisors, queues, schedulers, or a generic exactly-once guarantee. External systems remain ordinary tools, and Jixu does not claim enforceable exactly-once execution, which requires an idempotency contract in downstream systems.
Featured in Videos
YouTube tutorials and walkthroughs for Jixu
Alternatives
Similar projects ranked by category, topics, and text overlap.
