Arrowgram

Arrowgram is a self-reported tool for editing typed files (diagrams, papers, books, slide decks) that are legible to AI coding agents like Codex, while also being editable by humans visually. The system uses a file-first approach with a single source of truth in JSON and Markdown files, which can be edited both programmatically and through a browser-based visual editor. It supports local workflows via an open-source plugin and hosted workflows via a proprietary "GetPaidX" service that provides cloud workspaces and publishing capabilities.

The project is presented as a solution to the fragmentation between AI authoring tools and human visual editing, aiming to unify them within a shared artifact model. The authors claim it works with Codex and GPT-5.6 for research-authoring tasks and has been tested on a substantial formal-mathematics project (Emdash). However, no revenue, customer data, or traction metrics are provided.

The description states that Arrowgram is a visual editor and typed authoring system for commutative diagrams, research papers, books, and slide decks. It uses a file-first approach, with a single source of truth in ordinary files:

• arrowgram.workspace.json describes the workspace;
• diagram.json stores a standalone diagram using a strict schema;
• paper.md stores a paper, book section, or Reveal.js deck;
• paper.css controls publication styling.

Codex can edit these files directly. Arrowgram validates them and opens the same content in a visual editor. Changes made visually persist back to the workspace files.

Arrowgram also supports two complementary Codex integration paths:

1. The Arrowgram plugin: local and file-first, open-source.
2. The GetPaidX plugin: hosted and publishable, proprietary.

The system is built as an npm-workspace monorepo with three main public packages:

• @hotdocx/arrowgram (Zod schema, geometry engine, React SVG renderer);
• @hotdocx/arrowgram-web (visual workspace, paper editor, preview, browser persistence);
• @hotdocx/arrowgram-agent (file watcher, bridge API, validation, diff/snapshot behavior, static builds).

It uses technologies including React, TypeScript, Vite, Zustand, IndexedDB, KaTeX, Mermaid, Vega-Lite, Paged.js, and Reveal.js.

Inference: The product appears to be a hybrid system combining file-based editing with visual UI for human interaction, designed to support AI authoring workflows while maintaining compatibility with Git and local development practices.

The description states that Arrowgram was built because research diagrams rarely live alone, but instead belong inside proofs, papers, lectures, or books. The usual workflow splits the work across multiple tools (drawing tool, source files, local dev environment, publishing system), which is awkward for AI coding agents.

Arrowgram aims to solve this by making the diagram and paper themselves legible to Codex, editable by people, runnable in a browser, and publishable from a hosted AI workspace — without bolting a chat panel onto a canvas.

The authors claim that Arrowgram:

• Enables both human visual editing and Codex-editable artifact formats;
• Shares the same source model between local CLI and hosted workflows;
• Supports end-to-end workflows involving creation, drafting, diffing, building, snapshotting, and publishing;
• Is used in a real-world project (Emdash) involving formal mathematics and book production.

Inference: The positioning evolved from a general-purpose tool for AI-authoring to a specialized solution for research documents that require both machine-editability and human readability.

The description does not explicitly state the target customer or ideal customer profile (ICP). However, based on the content and use case described:

• Primary users appear to be researchers, mathematicians, or developers working in formal-mathematics contexts.
• These users likely work with typed files, diagrams, and research papers that need both AI assistance and human review.
• The system supports local workflows (via open-source plugin) and hosted workflows (via GetPaidX), suggesting a dual audience:
  • Developers or researchers who prefer local control;
  • Users who want cloud-hosted environments with persistent workspaces.

There is no mention of enterprise customers, non-academic users, or general-purpose developers beyond the context of research authoring.

Inference: The ICP likely includes researchers and developers in formal-mathematics domains, particularly those using AI coding agents for complex document authoring.

The description does not provide any information about business model or pricing. It mentions two paths:

1. An open-source Arrowgram plugin;
2. A proprietary GetPaidX plugin with hosted services.

It says that the GetPaidX plugin connects users' Codex CLI/app to a cloud-hosted API (https://getpaidx.com/api/mcp) via OAuth and offers curated tools for managing Arrowgram workspaces.

However, there is no evidence of:

• Revenue streams;
• Pricing tiers or plans;
• Customer acquisition costs;
• Monetization strategy;
• Subscription models or usage-based billing.

Inference: The business model remains unclear. It may be based on a freemium model (open-source plugin + paid hosted service), but this is not stated.

Arrowgram is built as an npm-workspace monorepo with:

• Three main public packages: @hotdocx/arrowgram, @hotdocx/arrowgram-web, and @hotdocx/arrowgram-agent.
• Core technologies include React, TypeScript, Vite, Zustand, IndexedDB, KaTeX, Mermaid, Vega-Lite, Paged.js, and Reveal.js.
• Tests are written using Vitest (unit/integration) and Playwright (browser flows).
• The system supports:
  • File-based editing;
  • Bidirectional synchronization between visual editor and source files;
  • Static builds to SVG, PNG, TikZ-CD, HTML/PDF, Reveal.js presentations.
• It integrates with Codex through two plugins:
  • Local: @hotdocx/arrowgram-agent;
  • Hosted: via GetPaidX MCP tools.

Inference: The technical architecture is modular and supports both local and cloud-based workflows. The system is designed for reproducible builds, version control integration, and AI-assisted editing.

The description states that Arrowgram was built as part of a Devpost submission to the OpenAI 2026 hackathon. It includes a case study involving Emdash — an experimental Lambdapi specification for functorial type theory and a future proof assistant.

Emdash is described as:

• A 192-page tagged PDF assembled from 32 ordered Markdown sources;
• A project that tests the full Arrowgram stack on a substantial formal-mathematics and book-production task;
• Used to validate artifact contracts, pagination, typography, accessibility, and deterministic output.

However, there is no evidence of:

• Revenue or monetization;
• Customer adoption or usage beyond the authors’ own development;
• Product-market fit or market traction;
• Any form of user feedback or product iteration history.

Inference: The system has been tested in a real-world academic context but lacks measurable traction or commercial validation.

The description does not mention specific competitors. However, it implies that Arrowgram addresses a gap in the current ecosystem where:

• AI coding agents like Codex struggle to work with fragmented workflows;
• Visual editors do not support programmatic editing;
• There is no unified model for combining human visual editing and machine-readable artifacts.

It positions itself as an alternative to traditional tools like:

• Drawing apps (e.g., draw.io);
• LaTeX-based systems (e.g., Overleaf, TeXstudio);
• Note-taking platforms (e.g., Obsidian, Notion).

Inference: Arrowgram operates in a niche space where AI authoring meets structured document editing. It competes with tools that support either AI authoring or visual editing, but not both simultaneously.

Several key risks and red flags are present:

1. No traction or revenue data: The project is described as a hackathon submission with no evidence of adoption or monetization.
2. Unclear business model: No pricing, monetization strategy, or customer base are mentioned.
3. Limited external validation: The only real-world test case is Emdash, which may not reflect broader usage patterns.
4. Proprietary vs open-source tension: While the local plugin is open-source, the hosted GetPaidX service is proprietary — this could create friction for users seeking full control.
5. Dependency on Codex/GPT-5.6: The system’s value depends heavily on AI coding agent availability and performance, which may not be stable or scalable.

Inference: Without external validation or commercial traction, Arrowgram risks being a proof-of-concept rather than a viable product for widespread use.

1. What is the actual adoption rate of Arrowgram among researchers or developers? Is there any data on how many people are using it?
2. How does Arrowgram plan to monetize its hosted service (GetPaidX)? Are there any pricing tiers or plans?
3. Can you provide examples of real-world projects where Arrowgram has been used beyond Emdash?
4. What is the roadmap for expanding support for other types of documents or formats beyond diagrams and papers?
5. How does Arrowgram handle security concerns around file access in hosted environments, especially with allowlists and OAuth?
6. Are there any plans to integrate with existing platforms like GitHub, Overleaf, or Jupyter?
7. What are the long-term goals for the open-source plugin versus the proprietary service?