DEV Community: Masaya Kumagai

Compare the methods of the papers you read, and decide what to try next

Masaya Kumagai — Sat, 07 Nov 2026 13:19:47 +0000

When you work out what to try next, you often read a few papers on similar work side by side. The trouble is that each paper writes its method in its own way. One gives the calcination temperature and time in the text, another puts them in a table, and a third only says "as reported before". To compare them you end up rebuilding the table yourself.

I have seen that rebuilding many times. What you want to compare is how the conditions differ, but first you spend the time putting the procedures into the same shape.

So in Graphium, you select the paper PDFs you brought in and have the AI extract their procedures, and each one becomes a procedure note. Operations, materials, instruments and conditions are marked from the start. Names are aligned too: an operation it can tell is the same gets the same name across papers. When it is unsure, it leaves the names apart rather than forcing them together.

With the procedures lined up, you can ask in the chat what to try next. Turn on Research before answering in Settings and start a chat without a note open, and the AI follows the procedures in the paper notes before it answers. That is why the answer says which steps of which papers it compared. One button turns the answer into an experiment plan note, with a table of the conditions to vary and one note per row holding the procedure with that row's values.

The other thing I cared about is where the plan comes from. In a plan an AI put together, you cannot see at a glance which parts were written in the papers and which are new decisions. So at the end of the plan note, the AI checks each condition, material, instrument and step of the plan against the notes the answer cited and the chat answer, and lists the result. Anything that differs from a note, or that is written nowhere (filled in by the AI), comes first. I think it makes clear where to look before you start the experiment.

Here is the whole flow as a video, no sound:

Two things to know before you try it. First, this flow runs in the desktop app (macOS and Windows). Second, it needs an AI: in Settings you pick a GitHub Copilot account or an API key for Anthropic or OpenAI. The extraction and the source check were tested with models like these.

The values in the plan are the AI's proposal. Graphium does not judge whether a plan is a good idea; that is only known once you run it, so I stopped at showing what the plan rests on. How accurate the procedure extraction and the source check are is measured and written up in the manual.

https://kumagallium.github.io/Graphium/manual/evaluations/extraction-accuracy-by-meaning

https://kumagallium.github.io/Graphium/manual/evaluations/plan-grounding-check

Graphium is a notebook with provenance. There is no account, and in the desktop app your notes stay in your own folder as plain files. It is open source under Apache-2.0.

https://kumagallium.github.io/Graphium/

https://github.com/kumagallium/Graphium

The detailed conditions I knew on the day I measured were gone when I looked at the graph later

Masaya Kumagai — Fri, 06 Nov 2026 01:23:26 +0000

When the .csv or .txt comes out of an instrument, the first thing you want is to plot the numbers and see whether the curve looks the way you expected. The file starts with a few lines of device name and settings, but right after measuring you have the conditions in your head, so you skip those lines, pull out just the numbers and plot them. Look at that graph weeks later and the finer conditions it was measured under are no longer there.

It is the same for me. On the day I measure, I know the conditions, so what I want to see is the shape of the numbers, and the header does not register. When I later wanted to check the detailed conditions, what I could rely on was the header that had stayed behind in the original file.

So Graphium has a data import that takes the instrument file as it is, header and footer included, and makes a table out of it. Choose a file from Data in the / menu, or drop the file onto the editor, and the screen opens with the header row, the row range and the delimiter already guessed. The original file is on the left and the converted table on the right, so you compare them and press Import. A header line like Device Model: ENV-MONITOR-X9 stays with the table as a measurement condition. A chart is drawn by pointing at this table by name, so behind the graph there is always a table with its conditions attached, and you can get back to the detailed conditions long after. Right after measuring it looks unnecessary, but I think it is the part of the record that matters later. The table gets a "from " badge next to its name, which reopens the same screen so you can adjust the range or delimiter and rebuild it. The original file stays as a material, so you can trace from the numbers in the table back to the raw data.

A measurement file with thousands of rows does not belong in a note as an ordinary table. Every edit rewrites the whole table and the editor stalls. So the default on import is a data table: the file stays as a material, the note holds only which material to read, how to read it and the table's name, and only the rows on screen are drawn. A 2,000-row log scrolls as lightly as a short table. When you want to edit cells directly, choose Table in the note on the import screen instead.

Data tables are read-only on purpose. The numbers came from an instrument, and I did not think editing them by hand belongs in a record. To change them, fix the original file and import it again. Tables in the note, for their part, cannot be imported above 1,000 rows.

Importing measurement data and data tables are covered in the "Notes & editor" page of the manual. Importing a file with its header came in v0.36.0 (2026-08-14), and keeping thousands of rows light as a data table came in v0.62.0 (2026-09-08).

https://kumagallium.github.io/Graphium/manual/notes-and-editor

Graphium is open source on GitHub.

https://github.com/kumagallium/Graphium

The notes you stopped reading can still answer you

Masaya Kumagai — Thu, 05 Nov 2026 08:09:19 +0000

Somewhere on your disk there is a folder you no longer open. Meeting memos, a few Word files, PDFs you meant to read twice, the notes from a project that ended. You wrote all of it, and none of it answers you anymore. When a question comes up that the folder could settle, it is faster to guess than to go digging.

I had the same folder. Mine was bread: twelve trials, each written up on the day. In trial seven only the flour changed, and at the same 75% hydration the loaf collapsed. The reason was in an earlier note and in a reading memo next to it, but I only found it by rereading all twelve.

So I built Graphium around that moment. You bring the folder in as it is, and the AI reads the notes and lifts topics out of them. Each line of a topic carries an @ back to the note it came from, and where two records disagree, the topic says so instead of smoothing it over. Then you ask. The answer is grounded in your own records and reading notes, and the citations open the source, so you can take the answer into the next attempt without wondering whether it was made up.

Here is the whole flow in one minute, no sound:

Three things to know before you try it on your own folder. First, this flow needs the desktop app (macOS and Windows); the browser version keeps notes in the browser and has no AI features. Second, asking the AI needs an AI: in Settings you pick which one to use, from a GitHub Copilot account, an API key for Anthropic or OpenAI, or a model running on your own computer. Third, if the records are sensitive, pick the model on your own computer (LM Studio or Ollama) and your notes stay there. If you only want to look, the sample notebook walks the same flow in the browser with no AI connected.

https://kumagallium.github.io/Graphium/app/?demo=bread-en

Graphium is a notebook with provenance. There is no account, and in the desktop app your notes stay in your own folder as plain files. It is open source under Apache-2.0.

https://kumagallium.github.io/Graphium/

https://github.com/kumagallium/Graphium

The Word files and PDFs I never reopened were still sitting in a folder

Masaya Kumagai — Thu, 05 Nov 2026 08:05:40 +0000

Years of records sit in a folder as Word files, PDFs, photos and Excel sheets. They would open if you tried, but you no longer remember where you wrote what, so every time you start something new, the old records stay unread.

I had the same problem. I kept the record of each step as a Word file and piled up papers as PDFs, but finding things cost more than it was worth, and in the end I moved on with only what I remembered.

So Graphium has an intake that takes a folder from your computer as it is. Press Bring in files in the sidebar, or drop a folder anywhere on the window. There is one rule: Markdown becomes notes, and PDF, Word, PowerPoint, Excel, images and CSV become materials. The folder layout is kept, PowerPoint files are unpacked into slide text and images, and Excel files into one table per sheet. Text inside images is read in the background after the intake finishes, so you can find it by search later. I thought it was better to get everything into one place first, and decide what to reread afterwards.

When it is done, a report says what came in: notes, materials, connections carried over and folders. From there you can go straight on to searching your notes, looking at the connections, or asking an AI.

The old formats .doc, .xls and .ppt are not taken in yet. They are not dropped silently; the report lists them by extension and count.

Bringing in files from your computer is covered in the "Materials & citations" page of the manual. Whole folders came in v0.63.0 (2026-09-08), and unpacking PowerPoint and Excel and reading text from images came in v0.65.0 (2026-09-08).

https://kumagallium.github.io/Graphium/manual/materials-and-citations

Graphium is open source on GitHub.

https://github.com/kumagallium/Graphium

Hand a plan and all its step notes to a person or an AI as one file

Masaya Kumagai — Thu, 05 Nov 2026 01:10:52 +0000

After weeks of trial and error, you may want to hand the work over to someone, or ask an AI "did this go as planned?" But when the record is split into one note per step, handing over the notes one by one leaves the other side to rebuild the planned order of the steps and what passed between them.

I have been there myself. I kept the record of each step as a Word file in a folder, while the plan as a whole mostly lived in my head. When I handed things over, the only way to pass on the connections was to explain them.

In Graphium, the plan that used to live in your head can be written down as a table in a plan note. Then Export plan provenance in that note's ⋯ menu saves the provenance of the plan and its step notes together as a single file, <title>.plan.jsonld. The export follows the W3C provenance standard (PROV) and a vocabulary for plans (P-Plan). Each row of the table becomes a step of the plan, and the planned links you drew in the step graph go in as connections between steps, along with the names you gave them. What the notes actually passed to each other carries the same names. I thought that putting the plan and what really happened side by side in the same words would let anyone read, outside Graphium too, whether things went as planned. Memos, image captions and the text you wrote between steps are included as well, so an AI reading the file sees what you wrote, not only the structure of the labels.

Rows with no note yet, or whose note is in the trash or the archive, still appear as steps, but without the contents of a note. A row whose name appears twice is not exported.

Exporting a plan's provenance is covered in the "Labels & provenance" page of the manual. Exporting a whole plan came in v0.104.0 (2026-10-29).

https://kumagallium.github.io/Graphium/manual/labels-and-provenance

Graphium is open source on GitHub.

https://github.com/kumagallium/Graphium

What Graphium can do 05: Use something made in another note as an input to this step

Masaya Kumagai — Mon, 02 Nov 2026 00:24:23 +0000

When trial and error goes on long enough, the work spreads across notes. Yesterday's curry, written up in one note, becomes today's curry udon in another. A bread starter you raised days earlier goes into the dough in the note for baking day. In both, something you made earlier becomes an ingredient of the next piece of work. In Graphium, open Prev step in a step's header, go to Choose from another note, and pick a note, a step and an output in turn. That output lands as a row in this step's input table. The row's name becomes a blue link that opens the source note alongside the current one.

When each note keeps its record to itself, it gets hard to trace later which day's curry went into the udon. So I chose to keep a "where it came from" link on what a step receives. Attributes such as temperature are copied as they were at the moment you picked them, and you can edit them freely in this note. The source note stays as it is. Its current values appear read-only in the step flow's table panel, labelled "From source".

When you repeat the same kind of work, the icon to the left of a step lets you pick from the names of steps you have written before. The parameters, materials and tools you recorded for that step are offered, and whatever you choose comes in empty. I think leaving last time's numbers in place risks a value you forgot to update being read as this run's condition.

If the reference to the source note breaks, the row's name turns red to show the broken link. Links that would form a loop are refused.

Linking from another note and inheriting from past steps are both covered in the "Labels & provenance" page of the manual. Inheriting from past steps came in v0.40.0 (2026-08-20), and taking an output from another note came in v0.42.0 (2026-08-24).

https://kumagallium.github.io/Graphium/manual/labels-and-provenance

Graphium is open source on GitHub.

https://github.com/kumagallium/Graphium

This week in Graphium (Oct 26 - Nov 1, 2026)

Masaya Kumagai — Mon, 02 Nov 2026 00:22:21 +0000

Each week I pick a few changes that landed in Graphium and explain why I made them. This issue covers five changes from v0.102.0 to v0.109.0.

1. Write a memo on whatever you are looking at

Press ⌘⇧M and the memo attaches to the paragraph or material in front of you. Images, videos and PDFs placed in a note get a small sticky-note marker in the corner, so the same memos can be read and added to from any note that uses that material. That way you no longer copy a memo about a photo into every note that shows it. A memo inserted into a note becomes a quote that stays linked to the original memo, and you can now also write memos on the lines between steps. (v0.109.0)

2. Excel and PowerPoint: look inside, edit outside, bring it back

Imported Excel and PowerPoint files can now be previewed inside Graphium. On the desktop app, a double-click opens the file in its own app, and when you come back Graphium asks whether to bring the edits in. If a note quotes that material, the original stays and the edited file is added as a new version. I did not want a quoted sentence to quietly turn into a different one. (v0.107.0, v0.108.0, v0.108.1)

3. Put a note beside the one you are writing, without linking it

While editing a note, pick another note or material from ⌘K and it opens side by side. Shift+Enter moves you there instead. An @-link to a note you only want to compare leaves a line in the provenance graph, so looking now stays out of the record. (v0.102.0)

4. Column attributes: dates, note links, protection

Instead of adding more kinds of tables, I went back to one kind and made "Fill in the date/time automatically", "Link rows to notes" and "Protect" attributes of a column. People asked for one table that tracks a series of experiments toward a single goal, and for a way to mark columns others should not touch when they receive a template. Protection is a guard against accidents that the recipient can also turn off, not a lock. (v0.105.0, v0.106.0)

5. Export a whole plan as PROV

A plan note's ⋯ menu now has "Export plan provenance". Each table row becomes a step, and the provenance of the step notes goes into the same file. Line names, image captions, memos and the text inside steps are exported too. If some information only lives on screen, it cannot be handed to an AI or another tool later. (v0.104.0)

The full list of changes, small fixes included, is in the release history of the manual.

https://kumagallium.github.io/Graphium/manual/release-history

Graphium is open source on GitHub.

https://github.com/kumagallium/Graphium

What Graphium can do 04: Start without an account, and your notes stay in your own folder as plain files

Masaya Kumagai — Thu, 29 Oct 2026 09:13:48 +0000

Have you ever gone back to notes you wrote years ago, only to find the subscription had lapsed, or that the export didn't come back in its original shape? I want a record of trial and error to outlive the thing I was making at the time. Graphium needs no account to start. In the desktop app, each note is saved as one JSON file in a Graphium folder inside your Documents folder. They are ordinary files you can see in your file manager, so any backup tool can handle them.

I decided that Graphium would have no cloud of its own. If a record is meant to last, I'd rather not tie its lifetime to whether a service keeps running. Instead, you choose the storage folder yourself under Settings → Storage → Where your notes are saved. Point it at a Dropbox, Google Drive or OneDrive sync folder, and your notes follow you across machines with no login and no extra service. The syncing is left to the client you already use; Graphium just writes files.

Changing the folder doesn't move existing notes, so copy the contents of the old folder into the new one and restart Graphium. The browser version keeps notes in the browser's own database, so clearing site data clears the notes too. For anything you want to keep, I recommend the desktop app.

How to choose the folder and how sync folders work are covered in the "Storage and sync" page of the manual. Graphium has worked without an account, and as a desktop app, since v0.3.0 (2026-04-12); choosing the storage folder came in v0.3.10 (2026-04-25).

https://kumagallium.github.io/Graphium/manual/storage-and-sync

Graphium is open source on GitHub.

https://github.com/kumagallium/Graphium

What Graphium can do 03: Calculate between cells of a table

Masaya Kumagai — Thu, 29 Oct 2026 02:08:48 +0000

When you write down a bread recipe, you often want the hydration: the weight of the water divided by the weight of the flour. A Graphium note has a calculation block that works things out as you type, with variables and units. Write cell("table", "row", "column") there, and it reads one cell from a table in the same note, so you can calculate between cells.

water = cell("Dough", "Water", "Weight")
flour = cell("Dough", "Flour", "Weight")
water / flour * 100

The row is found by the name written in the table's first column. You can also point at a row by its number, but then adding or reordering rows makes the line read a different value, and the line doesn't tell you which value it used. Since a note is a record, I wanted the line itself to read as "water weight over flour weight", so I made it look rows up by name. Units are read cell by cell, so even in a column that mixes g and mL, each value goes into the calculation with its own unit.

An empty cell isn't read as zero; the line says which cell is empty. It reads tables in the same note only.

How to write cell() is covered in the "Reading one cell" section of the manual. Available since v0.101.0 (2026-10-28).

https://kumagallium.github.io/Graphium/manual/notes-and-editor#reading-one-cell

Graphium is open source on GitHub.

https://github.com/kumagallium/Graphium

What Graphium can do 02: Wrap one piece of work in a step, and the order of your procedure becomes a diagram

Masaya Kumagai — Wed, 28 Oct 2026 01:27:01 +0000

Issue 01 was about marks that turn into a diagram. This issue is about the container those marks live in: the step block.

Baking bread is a run of actions: knead, proof, bake. A step is the editor's only container. It holds the text, tables and images of one action, and each step becomes one action in the diagram. Link steps with the Prev step chip in the header and the Next step chip at the bottom, and that order becomes the arrows in the graph.

The order of a procedure tends to blur when it is only prose. So I made it enough to wrap each action in a container and chain them, which keeps the order as structure. Outside a step, I kept Graphium a plain, quiet editor.

A step can also have stages. Write two or more rows in the parameter table, and each row becomes a stage. Baking with the temperature raised in three stages is one step with three stages, not three steps. My rule of thumb: split into steps when something is taken out or put in along the way, and add a stage when only the conditions change. The Add stage button adds the next row.

Details are in the manual: Labels & provenance. Step blocks have been there since v0.23.0 (2026-07-28); stages since v0.60.0 (2026-09-08).
GitHub: https://github.com/kumagallium/Graphium

What Graphium can do 01: Mark what you wrote as input or output, and a diagram of the steps builds itself

Masaya Kumagai — Mon, 26 Oct 2026 21:46:42 +0000

This series introduces what has been added to Graphium so far, one feature per post, as it works today. The first issue covers provenance labels, which have been there since the first release (their names and the way you add them have changed along the way).

Say you write down how you baked bread: flour, an oven, baking time, the loaf. Group the writing into steps, select the words that matter, and mark them as Input, Tool, Parameter or Output. A diagram of the steps (a provenance graph) assembles itself on the right. You never draw it. It works the same for cooking, woodworking or study notes.

I did not want to interrupt the writing. So I made it possible to write normally first and add the marks afterward. Only what you marked appears in the graph, so every node leads back to words you wrote yourself.

The provenance follows the W3C PROV-DM standard, and you can export it as PROV-JSON-LD from the note menu. Standard provenance tools outside Graphium can read it.

Only the words you marked show up in the provenance graph on the right.

Details are in the manual: Labels & provenance. Provenance labels have been there since v0.1.0 (2026-03-26); PROV-JSON-LD export since v0.2.0.
GitHub: https://github.com/kumagallium/Graphium

This week in Graphium (Oct 20-26, 2026)

Masaya Kumagai — Mon, 26 Oct 2026 21:46:38 +0000

Each week I pick a few changes that landed in Graphium and explain why I made them. This is the first issue, covering five changes from v0.92.0 to v0.95.8.

1. Choose what a meeting recording leaves in your note

Voice notes now keep cleanup and summary inside the block, and you pick what goes into the note. There is also a checkbox to hide names and contact details, and a choice of AI model for cleanup and summary. Pouring a whole meeting into a note lets the minutes take over the note, so I made keeping something a human decision. The hiding step sits before cleanup and summary, so other people's names in a recording are less likely to travel further. (v0.92.0, v0.94.0)

2. Connect GitHub Copilot with one button

On the desktop app, you can now connect GitHub Copilot with one button. Generating an API key and pasting it in was, I think, the biggest wall to starting with AI. If you already have Copilot, you can use it as it is. When the login expires, you can sign in again from Settings. (v0.92.2, v0.94.4)

3. Adding an AI starts with "Where do you want to connect?"

A screen that opens with "endpoint" and "model name" is hard to answer if you have not decided where to connect yet. I swapped the order. Opening "Connect with an API key" lists the services by name, with a switch to show only those with a free tier. I do not recommend any particular one. (v0.95.8)

4. See where a note sits in the whole experiment

The Genealogy tab shows a note's position as a process graph. It lays out the whole procedure below a plan, and in the global graph, selecting a node opens its genealogy beside it. I see the provenance of one note and its place in the whole as separate questions. (v0.95.4, v0.95.6, v0.94.12)

5. Pick what the AI may draw on, without opening a note

Standalone chat now has a grounding scope chip (External / Internal) and a screen with a chat list. I wanted you to choose the range the AI may use as evidence without opening a note first. The default is Internal. (v0.95.7)

The full list of changes is in the release history: https://kumagallium.github.io/Graphium/manual/release-history
GitHub: https://github.com/kumagallium/Graphium