jarvis

An agent-native personal operating system for people who live in Claude Code, Codex, and other coding-agent CLIs.

jarvis is a repo-shaped workspace that turns a coding agent into a durable research assistant, memory librarian, and local-tool operator. It gives the agent a clear filesystem contract, reusable skills, and a registry-backed toolbox so it can ingest sources, preserve raw context, synthesize knowledge, and safely run local utilities without turning your private vault into a pile of ad hoc notes.

This is not another "bring your own model runtime" agent framework. jarvis is designed to be used with a coding agent like codex or claude code. The package is the operating layer around that agent: the repo layout, prompts, workflows, guardrails, and deterministic tools that make the agent useful across weeks and months instead of one chat at a time.

Why jarvis exists

Most agent setups fall into one of two buckets:

• Chat-only assistants that are powerful in the moment but forget the structure of your world.
• Full agent runtimes that ask you to bring models, queues, orchestration, hosted services, or custom compute before you get value.

jarvis takes a different path. It treats Claude Code, Codex, or another capable coding agent as the compute layer and gives that agent a durable home:

• a stable memory vault with explicit boundaries
• an intake pipeline for raw material
• source-faithful notes before synthesis
• an LLM-owned wiki for compiled knowledge
• local skills for repeatable workflows
• a small command surface for tool execution
• safety rules for secrets, private data, and side effects

If OpenClaw-style tools are the claws, jarvis is the nervous system that tells an agent when and how to use them.

What you get

Durable memory layout

jarvis/
├── AGENTS.md          # canonical operating rules for agents
├── CLAUDE.md          # symlink to AGENTS.md for Claude Code compatibility
├── inbox/             # raw intake only
├── sources/           # source-faithful durable notes
├── wiki/              # synthesized Obsidian-compatible knowledge layer
├── .codex/skills/     # reusable agent workflows
└── _tools/            # deterministic local utilities

The core rule is simple: raw material goes into inbox/, preserved source notes go into sources/, and synthesized intelligence goes into wiki/.

Agent skills

jarvis ships with workflow skills for recurring knowledge work:

• process-this — full intake-to-source-to-wiki pipeline
• inbox-to-source — turn one raw inbox item into a source-faithful note
• source-to-wiki — integrate one source note into the compiled wiki
• github-to-source — analyze a GitHub repo into a durable source note
• youtube-transcript — capture YouTube transcript artifacts
• x-account-to-source — build X/Twitter account corpora
• wiki-query — answer from the wiki with trace logging
• wiki-maintenance — propose decay, drift, split, and cross-link fixes
• json-canvas and obsidian-bases — operate on Obsidian-native artifacts
• master-guide-prompt — turn a source note into a high-quality external prompt

These are not background daemons. They are instructions and workflows for your coding agent to execute deliberately.

Registry-backed tools

_tools/bin/jarvis is a thin CLI that reads _tools/registry.json, loads only the selected tool's local .env, sets the correct working directory, and delegates to the tool.

_tools/bin/jarvis tools list
_tools/bin/jarvis tools doctor
_tools/bin/jarvis run yt-dlp-client -- --help

The design keeps domain logic out of the runner. Each tool owns its own config, state, examples, and risk profile.

Positioning

jarvis is best understood as:

A local agent workspace for durable memory and tool use, powered by your existing coding agent.

It is adjacent to projects like OpenClaw, but the emphasis is different:

Category	OpenClaw-style tool projects	jarvis
Primary job	Provide capabilities/tools	Organize agent work and memory
Compute model	Often bring-your-own runtime or agent loop	Claude Code/Codex-powered by default
Unit of value	CLI, API, MCP, scraper, connector	Repeatable workflows + durable vault
Memory model	Tool-specific state or caches	Inbox → sources → wiki
Best user	Agent/tool builders	People who want an AI operator for their real knowledge work

The spin: jarvis is not trying to be the model. It is the home you give the model.

Example workflows

Process a link into durable knowledge

Ask your coding agent:

process this https://example.com/some-great-article

The intended flow:

1. Capture raw material into inbox/.
2. Create a source-faithful note in sources/.
3. Archive processed intake into inbox/_trash/.
4. Synthesize the durable lessons into wiki/.

Analyze a repository

process this https://github.com/someone/useful-repo

jarvis routes GitHub repositories through the repo-specific source workflow instead of treating them like ordinary web pages.

Query accumulated knowledge

what does my wiki say about browser automation tradeoffs?

The wiki-query workflow reads from wiki/ and records retrieval traces so future maintenance can identify hot nodes, stale pages, and missing links.

Design principles

• Agent-native, not agent-hosting. jarvis assumes the agent is Claude Code, Codex, or a similar coding CLI.
• Filesystem-first. Markdown, JSON, local folders, and explicit paths beat opaque databases for personal knowledge work.
• Source before synthesis. Preserve what the source said before asking the model to generalize.
• One item at a time. Batch ingestion is where context quality goes to die.
• Tools are delegated, not hidden. The CLI runner should stay thin and auditable.
• Secrets stay local. Each tool owns its own ignored .env and .state/.
• The wiki is allowed to evolve. wiki/ is the agent-owned intelligence layer; it can reorganize as retrieval needs change.

Getting started

1. Clone the repo.
2. Open it in Claude Code, Codex, or another coding-agent CLI.
3. Read AGENTS.md into the agent context.
4. Run the tool doctor:

_tools/bin/jarvis tools doctor

5. Add credentials only to the relevant ignored tool .env files.
6. Start with a single source:

process this <url-or-file>

What is intentionally not included

This public repo is a clean scaffold. It does not include a private inbox/, populated sources/, or personal wiki/. Those folders are intentionally present as empty directories so you can build your own memory from scratch.

jarvis also does not try to hide side effects behind a magical autonomous loop. The point is to make agent work legible, recoverable, and reviewable.

Who this is for

jarvis is for builders who already use coding agents heavily and want to turn them into a real operating system for research, memory, and local workflows.

If you want a hosted autonomous agent platform, this is probably not it. If you want a practical way to make Claude Code or Codex remember, route, ingest, and operate with discipline, jarvis is the missing layer.

Status

Early public scaffold. Expect rough edges, local assumptions, and fast iteration.