When the PDF becomes our interface for talking with AI

It often begins with a pause on page seven. You are reading through a manuscript you have spent months polishing, following a familiar line of argument, when your eyes catch on a subtyping relation. The symbols are all familiar and the equation is neatly typeset, yet the direction between the two types has quietly been reversed; two paragraphs down, the inline notation in the body text carries the same inversion forward; a glance to the side reveals a figure caption following suit. Across the page, the issue forms a single, unmistakable thread. You know at once where a reviewer will raise an eyebrow, and you know exactly where on this page the revision needs to begin.

Yet the moment you reach out to make the change, the page vanishes from view.

To act on an intuition formed on a rendered PDF page, traditional academic writing tools always demand that you leave the page behind and retreat into .tex source files crowded with dollar signs and backslashes. For decades, this split between thinking on the typeset page and laboring in the source code has been accepted as the unavoidable price of fine typesetting. Even now, when AI agents are remarkably capable of navigating multi-file projects, mainstream LaTeX tools remain trapped in a path dependency centered on source editing: they cram ever-smarter AI assistants into code panes while letting raw markup continue to dominate the main workspace, relegating the typeset manuscript to the very end of the pipeline as a mere secondary preview window.

I built Papilot because I could no longer tolerate this split and dislocation. I wanted authors to discuss how to revise a manuscript with AI directly on the page they are reading. When an author tells a story, expresses an intent to revise to AI, and ultimately judges whether an academic argument holds up, what they face is always the typeset page. Papilot therefore returns the main workspace entirely to the PDF manuscript itself, leaving no room in the interface for a permanent source editor. On disk, your project still consists of local .tex, .bib, and other plain-text files managed by Git. Whenever you want to inspect or edit the code by hand, you can open it in your favorite external editor, but the conversation between human and AI now returns to the same manuscript page.

Why Source-Centric AI Collaboration Is Already Outdated

The persistence of the split-screen interface is no accident; behind it lies an ingrained assumption that only the place where code is edited counts as the real workbench. Take Overleaf: its interface places the editing pane on the left and the PDF viewer on the right, letting users switch between a code editor and a visual editor, resize or collapse panes, recompile to refresh the output, and jump back and forth between source and layout. Even when panels are hidden or visual mode is enabled, the surface where the author makes edits remains separate from the final typeset page, and source editing still occupies center stage.

Dropping stronger AI models into this split-screen architecture does nothing to improve an author's workflow. Take the soon-to-be-defunct OpenAI Prism project: its built-in editor assistant can generate LaTeX snippets with "keep" or "undo" options, flag inline source errors, modify project files, and trigger recompilation while displaying the output in a separate PDF preview pane. Yet throughout that workflow, the conversation still revolves around source code. The author's question arises from the PDF, but the AI's revision is presented first as code. To judge the result, you have to return to the compiled manuscript, locate the spot corresponding to the change, and compare it piece by piece against what was there before.

It is precisely this back-and-forth locating and comparing that breaks the continuity of thought. Return to that inverted subtyping relation on page seven: after you state your request to the assistant in a source-first interface, what greets you is a sea of red and green source diffs. The \Gamma and \vdash inside a judgment, the \inferrule used to typeset a derivation rule, and your project's custom subtyping macros may all show up in the patch. Recompiling will of course give you an updated PDF, but a freshly compiled document does not show you how it differs from the old draft. You still have to track down the corresponding equation and check it against the previous version point by point: was the direction of the subtyping relation fixed properly, and were the body text and figure caption updated along with it? A source diff highlights insertions and deletions of commands, whereas what an author actually needs to review is the change those edits leave on the manuscript.

When the Typeset Page Becomes Shared Context

Once the rendered PDF stops being a passive preview at the end of the pipeline and becomes both the starting point and the destination of every revision, the relationship between human and AI changes accordingly. When you and the agent are looking at the same visible page of the manuscript, pointing replaces hunting.

In Papilot, making a revision feels as natural as two collaborators sitting at a table over a printed draft. You draw a box directly around the equation on page seven, highlight the sentence below that carries the inverted direction forward, and jot down a brief note pointing out that the subtyping relation is backward, asking AI to fix it and check the derivations that follow. You do not need to search across files for the corresponding \begin{mathpar}, nor do you need to copy fragments of code into a chat sidebar. The spatial position and surrounding context on the page itself provide the clearest context you could offer to AI.

Once you send the note, the connected AI agent goes to work in the .tex source files of your local project. It locates the right files, updates the equation and body markup, and hands the project to the compiler in the background to produce the new typeset output. When compilation finishes, what appears before you is not a dry code patch, but a before-and-after comparison rendered directly on the manuscript page. You inspect the old and new versions in their true font sizes, line spacing, and figure relationships, deciding on the spot whether to accept, reject, or leave a follow-up comment for further refinement.

Making the PDF the interface for conversation is by no means about turning a paper into an untraceable black box, nor is it about reverse-engineering arbitrary PDFs without source files. Papilot always runs on top of a real local LaTeX project, where ordinary plain-text files remain the single source of truth on disk and Git continues to preserve the history of the project's evolution. Reviewing changes in the interface and managing version history are kept cleanly distinct: clicking "Accept" on the page simply records your editorial judgment, whereas applying approved changes to the manuscript, committing them, or pushing to a remote repository always remains an explicit, separate step under your control.

Taking Responsibility for Every Change

Moving the interface from source code back to the manuscript also speaks to a more serious matter: a scholar's responsibility for their name on the paper. As AI grows ever more adept at polishing proofs, unifying notation across sections, and tightening wordy paragraphs, a subtler hazard emerges alongside it: plausible-sounding hallucinations and fallacies. An agent is entirely capable of producing a page of impeccably typeset prose while quietly relaxing the premises of a theorem during a rewrite, dropping a boundary condition, or overstating what an experimental curve actually supports.

When authors have to spend their energy deciphering source diffs, aligning table delimiters, and jumping across panes, the mental bandwidth left for scholarly scrutiny is inevitably diluted. Papilot strips away the visual noise of the markup layer and lets you compare before-and-after changes directly on the page, not to make decisions on your behalf, but to sharpen a scholar's eye. Visual clarity on the page never equates to scientific correctness; whether a theorem still holds, whether the notation is unambiguous, and whether every claim can withstand peer scrutiny are questions only the author can answer. When cumbersome markup recedes into the background, human academic judgment is brought squarely into the spotlight.

If you would like to experience this style of interaction before setting up a local project, you can open our interactive demo directly in your browser, where you can try the full loop of annotating on the page and reviewing before-and-after typeset comparisons without connecting a live AI or installing a local LaTeX environment. And when you are ready to connect your preferred agent to your own paper project and start writing, visit the Papilot GitHub repository to get the desktop client and full source code, released under the MIT license.

Returning to Page Seven

For a very long time, writing in collaboration with machines meant that humans had to learn to inspect their own thoughts through the machine's intermediate language. We grew used to piecing our meaning together across directory trees, code patches, and split-screen windows, treating the finished typeset page as a reward glimpsed only after a successful build.

Now, let us return to page seven. That inverted subtyping relation has been circled in the margin, the revised equation sits securely in its place, and the derivation beneath it reads with rigor and clarity. From spotting the flaw to completing the revision, your eyes never had to leave your own argument. The manuscript is finally whole again. Here is where you read, here is where you converse with AI, and here is where you stand behind every word on the page.