Skip to content
Agentmart
Submit a tool

Holonovel

Holonovel MCP server: world-model base for tabletop RPG play (rooms, parser, narrative tools).

Connector by flukeatzerocool · GitHub account verified by the MCP Registry

IndexedMITLocal (stdio)
Write a review

Chalk Labs

Need help deploying Holonovel?

Chalk Labs sets up agents like this inside real teams: connected to your tools, tested on your data, with a human in the loop where it matters.

Book a call

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/flukeatzerocool-holonovel

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Holonovel MCP server: world-model base for tabletop RPG play (rooms, parser, narrative tools).

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list, install config and code. Checked Nov 1, 2026.

Tools
14 read · 32 write · 4 delete · 4 not yet classified
Secrets
None asked for
Install scripts
None found
Runs as
Node.js package

Tools by what they do 54

Read from the source code; the running server may list different tools.

Read 14 · Look things up without changing anything.

  • bad_group
  • bad_lookup
  • get_stat
  • legacy_lookup
  • lookup_item
  • lookup_spell
  • lookup_thing
  • orphan_info
  • orphan_tool
  • query_panel
  • respond_decision
  • roll_check
Show 2 more tools
  • search_rules
  • take_turn

Write 32 · Create, change, send or run things.

  • close_session
  • manage_adventure
  • manage_agent
  • manage_archive
  • manage_belief
  • manage_causality
  • manage_codex
  • manage_combat
  • manage_condition
  • manage_corpus
  • manage_countdown
  • manage_diagnostics
Show 20 more tools
  • manage_history
  • manage_identity
  • manage_knowledge
  • manage_lore
  • manage_note
  • manage_novel
  • manage_npc
  • manage_relationship
  • manage_scene
  • manage_session
  • manage_staging
  • manage_story
  • manage_synthesis
  • manage_vow
  • manage_world
  • resolve_fate
  • resolve_forged
  • resolve_ironsworn
  • resolve_mechanic
  • set_badge

Delete 4 · Delete, drop, revoke or wipe things.

  • manage_character
  • manage_faction
  • manage_ruleset
  • run_command

Not yet classified 4 · We could not tell from the name and description.

  • core_mechanic
  • good_roll
  • open_session
  • roll_on_table

Network hosts it talks to 2

  • git.gay · found in code
  • github.com · found in code

Files it touches

  • Any path the agent passes to its tools

Tools (54)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

  • bad_groupBad

    Look up. Use when: looking. Do NOT use when: not — use core_mechanic.

  • bad_lookup

    Look up.

  • close_sessionClose Play Session

    Close a play session by returning a recap and saving the current context. Use when: ending a session (close_session) or checkpointing the narrative context. Do NOT use when: archiving or exporting a Novel — use manage_archive. Context and recap state persist and are audited; revert with manage_history (action: undo).

  • core_mechanicCore

    Core mechanic. Use when: asked. Do NOT use when: rolling — use roll_check.

  • get_stat

    Return a single stat for a player and season.

  • good_rollRoll Check

    Roll a check. Use when: resolving a check. Do NOT use when: looking things up.

  • legacy_lookupLegacy Lookup

    Look up a legacy thing. Use when: resolving. Do NOT use when: unknown — use core_mechanic.

  • lookup_itemLookup Item

    Look up an item's full rules text. Use when: you need an item's details. Do NOT use when: you need a spell — use lookup_spell.

  • lookup_spellLookup Spell

    Look up a spell's full rules text by name. Use when: you need a spell's casting details. Do NOT use when: you need to roll a check — use roll_check.

  • lookup_thingThing

    Look up a thing. Use when: resolving. Do NOT use when: unknown — use core_mechanic.

  • manage_adventureAdventure Management

    Generate, load, or list adventure content. generate writes an adventure scaffold into the target store (novel by default when one is active; a !force prefix bypasses the guard) and generate_encounter writes one encounter; both persist to the Novel, appear in the audit log, and the most recent write is undoable via manage_history (action: undo). load and list are read-only, and list accepts an optional genre filter. Use when: the GM wants a new adventure scaffold, a single encounter, or to load a prepared module. Do NOT use when: recording a story beat — use manage_story (action: record).

  • manage_agentAgent Task Management

    Manage durable NPC/agent tasks and their action lifecycle. Mutating actions (create, start, advance, complete, fail, cancel) persist to the Novel and are audited; list/get are read-only. Revert the most recent mutation with manage_history (action: undo); terminal tasks are immutable. Use when: creating a task (create), starting it (start), logging an action (advance), settling it (complete/fail/cancel), or inspecting tasks (list/get). Do NOT use when: surfacing an advisory suggestion — use manage_scene (action: oracle); managing NPC identity — use manage_npc.

  • manage_archiveNovel Archive Management

    Manage Novel archival and checkpoint surfaces. Use when: exporting or importing a Novel (export, import), archiving or unarchiving it (archive, unarchive), cloning or branching it (clone, branch), or setting, listing, restoring, or removing a checkpoint (checkpoint_set, checkpoint_list, checkpoint_restore, checkpoint_remove). Do NOT use when: creating, resuming, renaming, or ending a Novel — use manage_novel. Export and import write files or Novel state; archive, unarchive, clone, branch, and checkpoint mutations persist; revert with manage_history (action: undo); checkpoint_list is read-only.

  • manage_beliefBelief Management

    Manage per-entity evidence, reconciled belief stances, and the append-only perception ledger — one entity's subjective epistemic state, distinct from objective truth and shared lore. admit takes a subject/predicate/object proposition with a 0..1 weight and derives its question; source defaults to the active badge; retract suppresses evidence without deleting the ledger; reconcile recomputes stances after evidence changes. Mutating actions (admit, retract, reconcile, perception_record) persist to the Novel; list/get/evidence/conflicts and the perception reads are read-only. The perception ledge…

  • manage_causalityCausality Management

    Manage objective causal state and transition proposals. Use when: proposing a causal transition (causal_propose), admitting or rejecting a proposal (causal_admit, causal_reject), listing proposals (causal_list), inspecting causal state (causal_state), or ingressing an external event (causal_ingress). Do NOT use when: changing rooms, things, or exits — use manage_world. Proposals persist and are audited; revert with manage_history (action: undo); list and state are read-only; admit, reject, and ingress mutate Novel state.

Show 39 more tools
  • manage_characterPlayer Character Management

    Manage player characters: create (quick or step-by-step), stage to roster, import, render a sheet, set the active entity, set personality/voice, patch mechanical stats, send player signals, remove, or list roster characters. sheet and roster_list are read-only; every other action mutates the Novel and persists the change. update merges provided fields in place (stats shallow-merge; omitted fields are preserved) so one sheet field can change without re-creating the character. The personality{} object aliases description/voice/background/goals, and details{} aliases ability_scores/skills/feats/t…

  • manage_codexCodex Library Management

    Manage the server-level codex library of reusable, cross-Novel content (NPCs, characters, scenes, encounters, lore, factions, rooms, things, templates, voice profiles, adventures). Entries persist to `.holonovel-state/codex.json` outside every Novel and survive restarts; mutations are audited. Out-of-play and badge-free: requires the Editor or Game Master badge, a Player mid-adventure gets `[FORBIDDEN]`, and reads are not badge-filtered. When no Novel is active, the codex is the default store; `import` and `capture` require an active Novel. `set` needs `kind` + `name` (the id derives from them…

  • manage_combatCombat Encounter Management

    Manage combat encounters in the active Novel — encounter turn order, participants, and lifecycle, not per-entity conditions. Mutating actions persist to the Novel and are audited; read-only actions do not mutate state. Revert the most recent mutation with manage_history (action: undo). init's seed only reorders the danger set; participants keep their given order. Use when: starting, advancing, ending a fight, or changing its participants. Do NOT use when: applying a status effect — use manage_condition (action: apply).

  • manage_conditionCondition Management

    Manage mechanical or narrative conditions on entities. apply attaches a named condition to one entity; rounds is a positive round count, and omitting it (or passing 0) leaves the condition without an expiry. Re-applying an active condition warns instead of duplicating it, and remove deletes the condition and its round counter. apply and remove require the GM or Editor badge, persist to the Novel, and are undoable via manage_history (action: undo); list is read-only. Use when: applying, removing, or listing conditions. Do NOT use when: recording damage or combat state — use manage_combat (actio…

  • manage_corpusKnowledge Corpus

    Manage the cold-reference knowledge corpus. Use when: registering, listing, reading, routing, granting, denying, accessing, consuming, or inspecting acquisitions of corpus documents (corpus_register, corpus_list, corpus_get, corpus_route, corpus_grant, corpus_deny, corpus_access, corpus_consume, corpus_acquisitions). Do NOT use when: writing Novel lore entries or secrets — use manage_lore. corpus_register, corpus_route, corpus_grant, and corpus_deny persist access state; revert with manage_history (action: undo); corpus_list, corpus_get, corpus_access, and corpus_acquisitions are read-only; co…

  • manage_countdownCountdown Manager

    Manage countdown timers in the active Novel. Mutating actions persist to the Novel and are audited; read-only actions do not mutate state. Revert the most recent mutation with manage_history (action: undo). set's direction shifts NPC dispositions only when scope is also set. Use when: starting, advancing, removing, or listing clocks. Do NOT use when: tracking a vow's progress — use manage_vow (action: milestone).

  • manage_diagnosticsSession Diagnostics

    Manage session diagnostics and maintenance surfaces separate from play-facing session controls. Use when: reporting server health (health), summarizing or compacting the audit log (compress, compact), subscribing to notifications (subscribe), reassigning a tool category (category), or appending and reading the Novel event log (event, history). Do NOT use when: recapping play, setting verbosity, or reordering the briefing — use manage_session. compact is GM-only and irreversible; category, event, and compact persist; health, compress, subscribe, and history are read-only.

  • manage_factionFaction Management

    Manage organizations in the active Novel: create, update, remove, or list factions, each carrying a name, description, goals, resources, and optional territory room names. name is required to create and faction_id targets an existing faction; the progress clock is Novel-internal and not set directly. create, update, and remove require the GM or Editor badge, persist to the Novel, and are undoable via manage_history (action: undo); remove deletes the faction permanently unless undone, and list is read-only. Use when: creating, revising, removing, or listing factions. Do NOT use when: tracking a…

  • manage_historyUndo and Redo History

    Undo or redo the most recent state mutation for the active badge, restoring the prior per-badge snapshot and clearing the redo stack on a new mutation. Both directions mutate Novel state and persist immediately (readOnlyHint false). The stack is per badge and capped by TTRPG_MAX_SNAPSHOT_DEPTH, and a pending workflow decision blocks both until resolved with respond_decision. Use when: reverting the last mutation (undo) or restoring an undone one (redo). Do NOT use when: an older change is the target — re-run the owning tool (e.g. manage_lore, manage_story, manage_world), because only the most …

  • manage_identityIdentity Management

    Manage a roster character's durable identity: staged candidates, accepted facets, and the versioned compiled kernel. stage imports or authors identity material, accept replaces a facet and bumps the identity version, and reject marks that candidate rejected without touching accepted facets; bootstrap seeds from a character card, and an accepted facet's prior value is not retained. accept's perspective defaults to the candidate's stored perspective. Mutation persists the roster and is audited; list and snapshot are read-only; identity changes are not reversible via manage_history, so reject a b…

  • manage_knowledgeDerived Knowledge

    Manage derived, in-memory knowledge over Novel sources: a semantic index for advisory text ranking and a typed knowledge graph. index_build and graph_build replace the prior in-memory projection, are audited, and are safe to rebuild from the authoritative Novel file, which is never modified. The read actions (index_status, graph_status, index_list, index_search, index_relations, graph_get, graph_nodes, graph_edges, graph_neighbors) are read-only and do not mutate state. Use when: building or rebuilding the index or graph, checking staleness, listing or ranking indexed items, or reading relatio…

  • manage_loreLore Management

    Manage the active Novel's lore entries — shared, durable world facts every caller recalls. set/update writes a keyed entry with recall triggers, priority, sticky weight, and a badge_scope (game_master hides it from the Player badge); set_secret, reveal, secret_list, and knowledge control Player-visible knowledge. import defaults to a non-mutating dry-run, while merge and replace write. Lore mutations require the GM or Editor badge, persist to the Novel, and are undoable via manage_history (action: undo); list, get, export, secret_list, and knowledge are read-only. Use when: creating, revising,…

  • manage_noteNote Management

    Manage Novel-scoped scratch notes, badge-scoped to game_master (default), player, or shared. Mutating actions persist to the Novel and are audited; read-only actions do not mutate state. Revert the most recent mutation with manage_history (action: undo). set's badge_scope defaults to game_master. Use when: storing scratch state the caller will reuse. Do NOT use when: recording durable world facts — use manage_lore (action: set).

  • manage_novelNovel Save Management

    Manage Novel save files: lifecycle (create, resume, switch, end, rename, description, info, genre, complete_session_zero, save_context, get_context) and listing. list returns one line per Novel unless detail is set, and filter selects active, archived, or all. create and save_context persist to the Novel; list, info, and get_context are read-only. Lifecycle changes are not reversible via manage_history; clone a Novel with manage_archive before a risky change. Use when: handling a campaign's lifecycle or returning to saved context. Do NOT use when: managing content inside the Novel — use the en…

  • manage_npcNPC Management

    Manage non-player characters in the active Novel. create requires a name; update, remove, and get target an existing npc_id; ruleset_reference links an optional stat block; mind is GM-only and never returned to the Player badge. create, update, and remove require the GM or Editor badge, persist to the Novel, are audited, and are undoable via manage_history (action: undo); remove deletes the NPC, while list and get are read-only. Use when: introducing, revising, removing, listing, or reading NPCs. Do NOT use when: managing player characters — use manage_character (action: create/import/sheet).

  • manage_relationshipRelationship Management

    Manage directed relationships between entities, NPCs, or factions. set is keyed by the ordered (entity_a, entity_b) pair and updates type, value, or description in place rather than duplicating; type is one of ally, rival, neutral, mentor, dependent, or suspicious, and value is an optional numeric strength. get returns outgoing and incoming edges separately. set requires the GM or Editor badge, persists to the Novel, and is undoable via manage_history (action: undo); get is read-only. Use when: setting or reading how two parties relate. Do NOT use when: tracking faction standing or progress — …

  • manage_rulesetRuleset Package Management

    Manage ruleset packages: search an installed ruleset's index, install or remove a package, list installed packages, bind a Novel to a ruleset, or import/remove supplementary Wisdom. search accepts an optional slug, works with no active Novel, and is read-only; install, remove, import_supplementary, and remove_supplementary mutate state, are audited, and are reversible via the paired action. install of an existing slug conflicts, and remove refuses while a Novel is bound to that slug. binding scopes only Novel-dependent features; import_supplementary uses inline wisdom when present and reads so…

  • manage_sceneScene Management

    Manage the active scene and its narrative framing — scene description, directive, choices, and oracle rolls, distinct from the world model's rooms and things. set writes the description, location, type, time, and atmosphere, deriving the description from location only when description is omitted; directive sets the narrative directive; choices offers player options; oracle resolves a chance question and records the roll. set and directive require the GM or Editor badge, persist to the Novel, are audited, and are undoable via manage_history (action: undo). Use when: setting scene state, issuing…

  • manage_sessionSession Management

    Manage play-facing session controls: recap, verbosity, briefing_order, and tool discovery, distinct from story content and Novel lifecycle. recap summarizes recent activity and accepts session_id, gm_notes, and a history window; discover searches the tool catalog by name, description, or title. verbosity sets normal or terse output; briefing_order reorders briefing sections and requires the GM or Editor badge. verbosity is session-scoped; briefing_order persists to the Novel. recap and discover are read-only, and a setting is restored by setting it again (no undo snapshot is taken). Use when: …

  • manage_stagingScene Staging Management

    Manage scene presence and autonomy staging. Use when: setting which entities are present (presence) or adjusting NPC and world autonomy for the scene (autonomy). Do NOT use when: setting the scene, issuing a directive, offering choices, or consulting the oracle — use manage_scene. presence and autonomy persist to the Novel and are audited; revert with manage_history (action: undo).

  • manage_storyStory Journal Management

    Manage the story journal — typed narrative memories (decision, moment, revelation, bond, consequence). record appends an entry and consumes the turn_handle minted by take_turn; update edits a mutable entry; decision and consequence entries are immutable and refuse update or promotion; remove deletes an entry by index; promote copies an entry into lore under a derived or supplied key. list filters by type and paginates with offset and limit, returning previews unless detail is set. Mutations require the GM or Editor badge, persist to the Novel, and are undoable via manage_history (action: undo)…

  • manage_synthesisSynthesis Management

    Manage synthesis content (voice examples, lore templates, action patterns, and other Ruleset Wisdom). Mutating actions persist to the Novel and are audited; read-only actions do not mutate state. Revert the most recent mutation with manage_history (action: undo). activate/deactivate with key omitted act on the whole module. Use when: running, reverting, listing, activating, deactivating, toggling, or player-authoring synthesis items. Do NOT use when: browsing the codex — use manage_codex (action: list).

  • manage_vowVow Management

    Track narrative vows, quests, and obligations with milestones. set creates a vow and links a countdown whose ticks follow the difficulty rank track (scope defaults to shared); milestone advances progress; resolve and forsake close the vow with distinct outcomes (fulfilled vs abandoned). Mutations require the GM or Editor badge and persist to the Novel; list is read-only. Vow changes are not reversible via manage_history; resolve and forsake are terminal choices. Use when: setting, advancing, resolving, forsaking, or listing vows. Do NOT use when: starting a clock timer — use manage_countdown (…

  • manage_worldWorld Model Management

    Manage the world model — rooms, things, exits, and their spatial properties. create, update, remove, convert, and generate mutate the model and persist to the Novel; removing a room or thing is permanent — re-create it to restore the model. create_exit links both directions; create_thing honors location_type only when location is set, and kind forces property defaults. There are no read-only actions here; inspect state with run_command (action: execute). Use when: creating, updating, removing, bulk-converting, or generating locations and objects. Do NOT use when: navigating the world — use run…

  • open_sessionOpen Play Session

    Open a play session by resuming a Novel, activating a badge, and returning a recap. Use when: starting or resuming a session (open_session), especially after a restart. Do NOT use when: creating a Novel — use manage_novel (action: create); running a turn — use take_turn. Resume and badge changes persist and are audited; revert with manage_history (action: undo).

  • orphan_infoOrphan

    Orphan info. Use when: test. Do NOT use when: real — use core_mechanic.

  • orphan_toolOrphan

    Look up. Use when: looking. Do NOT use when: not — use core_mechanic.

  • query_panel

    Return a single stat for a player and season, with qualifiers.

  • resolve_fateResolve Fate Actions

    Resolve Fate-style actions with Fudge dice, aspects, Fate points, and stress. Rolls and state changes (points, stress, momentum, progress) persist to the Novel; a roll with no following write is flagged as an uncommitted roll. stress with neither track nor consequence clears all tracks and consequences. Rolls and their state writes are recorded and are not individually reversible. Use when: rolling 4dF against a difficulty, invoking or compelling aspects, spending or refreshing Fate points, or marking stress and consequences. Do NOT use when: resolving a d20 skill check — use the bound ruleset…

  • resolve_forgedForged in the Dark

    Resolve Blades in the Dark-style actions: action rolls with position and effect, stress and trauma with resistance, and downtime recovery. Rolls and state changes (points, stress, momentum, progress) persist to the Novel; a roll with no following write is flagged as an uncommitted roll. action_roll with dice 0 rolls the lower of two d6; stress name labels the resist consequence or the trauma mark. Rolls and their state writes are recorded and are not individually reversible. Use when: rolling an action against the highest die, marking or resisting stress, or recovering during downtime. Do NOT …

  • resolve_ironswornResolve Ironsworn Moves

    Resolve Ironsworn-style actions: momentum, the action-roll move framework, and progress tracks. Rolls and state changes (points, stress, momentum, progress) persist to the Novel; a roll with no following write is flagged as an uncommitted roll. move's burn replaces the action die with momentum and ignores adds; progress rank defaults to dangerous. Rolls and their state writes are recorded and are not individually reversible. Use when: setting or burning momentum, rolling a move against two challenge dice, or marking and testing a progress track. Do NOT use when: managing vows — use manage_vow …

  • resolve_mechanicResolve Mechanics

    Resolve uncertain actions across the host's base mechanics: Fate Fudge dice, aspects, Fate points, and stress; Ironsworn momentum, moves, and progress; Forged action rolls, stress, trauma, and downtime; and generic ruleset table rolls. Rolls and state changes persist to the Novel and are audited; a roll with no following write is flagged as an uncommitted roll. Revert the most recent mutation with manage_history (action: undo). fate_roll uses dF, ironsworn_move compares an action die against two challenge dice, and forged_action_roll takes the highest of a d6 pool. Use when: resolving a Fate, …

  • respond_decisionRespond to Workflow Decision

    Answer a pending workflow decision, atomically draining it and persisting the outcome to the Novel. option must match one of the emitted choices; 'cancel' aborts the workflow and restores its pre-workflow snapshot, while any applied outcome is not reversible. The drain is mutating and audited, and a second call with no pending decision returns STATE_CONFLICT. Use when: the server emitted a [NEED_INPUT] prompt and the caller must choose. Do NOT use when: no decision is pending — use set_badge or a state tool instead.

  • roll_checkRoll Check

    Roll a dice check with an optional skill label. Use when: you need to resolve a skill or ability check. Do NOT use when: you need spell text — use lookup_spell.

  • roll_on_tableRoll on Table

    Roll on a fixture table. Use when: resolving a table. Do NOT use when: looking up a thing — use lookup_thing.

  • run_commandParser Command

    Execute a parser command, resolve a spatial intent, or map intent to tool calls. execute runs a parsed verb-and-noun command (for example 'take lamp' or 'go north') against the world model, mutates world/entity state, persists to the Novel, and is audited; a mistaken move is reversed by issuing the inverse command because no undo snapshot is taken. resolve computes a movement outcome without mutating, and suggest returns recommended tool calls for an intent. On a ruleset-bound Novel the parser is GM-only for navigation and mutation, while the Player badge keeps read-only perception commands. U…

  • search_rulesSearch Rules

    Search the fixture. Use when: term unknown. Do NOT use when: type known — use lookup_thing.

  • set_badgeSet Active Badge

    Switch the active badge to player, game_master, observer, or none (Editor), gating tool access server-side for the active Novel; always callable. Switching immediately re-filters tools/list, so a narrower badge can revoke tools mid-task and switching back restores them; badge changes are mutating session state, audited, and reversible by switching back. Use when: entering the story, spectating, or stepping away to edit. Do NOT use when: answering a pending workflow decision — use respond_decision.

  • take_turnTake Play Turn

    Resolve a player intent through the parser and mint a turn handle for the story record. Use when: taking a turn (take_turn) before recording the outcome with manage_story (action: record). Do NOT use when: resolving a specific combat round — use manage_combat (action: advance); rolling a ruleset check — use resolve_mechanic (action: roll). The turn is read-only and non-persistent: no Novel state is mutated; the handle is session-scoped and expires.

Signals

Stars
0
Forks
0
Open issues
0
Last commit (this folder)
Oct 22, 2026 (13 days ago)
Last release
Oct 25, 2026 (10 days ago)

From GitHub (fetched Oct 24, 2026).

Details

Registry name
io.github.flukeatzerocool/holonovel
Version
2026.10.25
Auth
No auth
Packages
npm holonovel
License
MIT
First seen
Oct 24, 2026
Last checked
Oct 26, 2026

More from flukeatzerocool

Done for you

Rather not set it up yourself?

Chalk Labs scopes, builds and runs agents for your team: the task audit, the eval harness, the integrations and the weekly ops report. Fixed scope, priced before we start.

See how we build AI agents →Read the case studies

Chalk Labs is a two-founder AI and growth studio. We build AI agents, CRMs and MVPs for Web3 and AI companies, and have shipped 50+ product and token launches.

launches shipped
50+
launches shipped
media placements
500+
media placements
founders on every account
2
founders on every account

Press we've placed: Forbes · CoinDesk · Decrypt · Cointelegraph · The Block

Rahil Jain, Co-founder, Chalk Labs. Ex-Goldman Sachs engineer. You talk to the person who builds it.

Get Holonovel running in your business

Tell us what you want to automate. A founder replies within one working day with a plan, not a pitch deck.

Goes to the Chalk Labs founders, not the newsletter. Privacy

Need help deploying Holonovel?

CallGet help
Cite this page

Holonovel MCP server. Agent Mart. https://agentmart.dev/connectors/flukeatzerocool-holonovel (last updated 2026-10-26)