LLM / RAG |

Multi-Agent Development Workflow

Sun, 27 Sep 2026 00:00:00 +0000

For a website revision, I can give an agent the editorial guide and a set of pages, then review the resulting changes before publishing. That work happens in its own working copy, so another task can proceed without sharing the same files. The handoff carries the branch, changes, checks, and remaining questions.

Git calls these separate working copies worktrees. Each writing task gets one branch and one writer; a designated integrator combines finished changes. The files and staging areas are separate, but Git’s underlying history and branch references are shared. Isolation reduces accidental overwrites while leaving conflicts and incompatible changes for review.

The workspace’s routing guide assigns defaults by task. Claude handles architecture and decisions that depend on earlier context. Gemini handles pipeline operation, documentation, writing, and large source reviews. Codex handles routine code maintenance, tests, and Git mechanics. An explicit assignment can override those defaults—as it does when I ask Codex to revise these pages.

The routing instructions live in one shared document, linked from each agent’s entry file. That avoids maintaining three copies that can drift apart. Continuity comes from the context and records supplied in this workspace; it should not be assumed to be automatic or shared between products.

A completed task still needs integration approval. Its handoff identifies what was changed, what was checked, and what remains uncertain. A passing test suite does not establish that two independently sensible changes will work well together.

This remains a convention the participants must follow. Worktrees do not isolate a shared notes vault, an external service, or a sync process. The and describe the boundaries and approval rules.

Resume Manager

Wed, 09 Sep 2026 00:00:00 +0000

A useful tailored resume changes the emphasis without changing the experience. Resume Manager keeps a master record of my roles, projects, and accomplishments, then uses a job description to select relevant experience and rewrite its bullets. Employer names, dates, and locations are copied by code from the master; the model supplies bullet wording rather than rebuilding the whole document.

The most effective change was removing AI from the first step. My source resume already had recognizable sections, but model-based extraction misplaced fields and omitted information. A conventional parser that reads those sections reduced the recorded bootstrap time from over 90 minutes to about 1.5 seconds on my resume. Language generation remains useful for tailoring; it was unnecessary for reading a layout the code could recognize directly.

What tailoring can change

An illustrative example for a hypothetical applicant applying to a monitoring role:

Master: Prepared monthly monitoring reports in Excel covering 12 projects.

Tailored for a role emphasizing Excel: Prepared Excel monitoring reports for 12 projects each month.

The revised bullet puts Excel first while keeping the frequency, activity, and project count fixed. It adds no claim of managing those projects or improving their results. That is the kind of distinction I still review in the actual output; fixed dates alone cannot protect every factual implication of a rewritten sentence.

The ordinary workflow uses a saved job description and a local model. Optional questions let me explain priorities before tailoring, and the application folder keeps that guidance alongside the job description, draft, PDF, and validation report. A separate route can interpret a rough opportunity description and request a cloud-based relevance brainstorm. That route may send resume material to Gemini; the saved-description route does not require it.

Check what survived the rewrite

Checks flag possible invented or dropped numbers, repeated openings, similar bullets, and some unsupported responsibility wording. Explicitly supplied facts can include required phrases or acceptable alternatives, making omissions easier to spot. These are advisory checks, not a full understanding of whether the resume is faithful.

The September 2026 application trials showed why that matters: a rewrite dropped a financial figure, and another output omitted qualitative guidance despite a clean numeric report. Newer checks cover more of those cases, but word matching and similarity tests can still miss changes in meaning.

Page fitting ranks candidate experience and measures rendered drafts against a target length, so content selection responds to the available space. I still inspect the final PDF for readable layout and omissions. The master remains maintained by hand, and tailoring never submits an application. The explains the current entry points and review outputs.

Academic Hub

Tue, 01 Sep 2026 00:00:00 +0000

As a PhD student, a common problem is having too many learning resources and not enough time to explore them all. Synthesizing information from textbooks, lecture slides, recitation notes, past exams, and external content and distilling the most important lessons is a massive challenge, especially for multiple overlapping courses. A question I jotted down during lecture in my handwritten notes may require leafing through a textbook index, cross-checking against the notation used by my specific faculty, and connecting back to an example from a past semester’s problem set. Online searches or generic AI responses are faster, but lack the specific context from my own materials; usually LLM responses are based on other disciplines or invoke concepts far out of scope for my course.

My solution is the Academic Hub: a complete system for organizing my notes and course materials in a machine-readable format that a locally based AI agent can use to serve as my personal librarian and tutor. An interconnected group of customizable coding pipelines take my disorganized notes, slides, and syllabi and turns them into a fully searchable corpus of data, complete with metadata tags, which a local or low-cost AI model can use to generate customized study guides, practice problems, and Socratic tutor agents. The entire system is built to be reproducible for any course and any type of input: handwritten notes, slides, scans of textbooks, typeset PDFs–just drop a collection of study materials into a course directory, use a local agent to run the conversion and tagging pipelines, then start building custom materials from the resulting knowledge corpus. The system is also built to prioritize free or low-cost methods for transcribing content, relying on local LLMs or subscription models where possible and falling back to APIs if necessary, to ensure complete customizable to the user’s cost sensitivity and preferred LLM environment.

The common foundation for every course is a collection of materials transcribed into a machine-readable format, typically markdown or JSON databases. Converting notes or slides preserves the text, mathematical notation, and page context; the makes that material searchable by a local agent or using backlinks in a notes aggregator like Obsidian. From there I can ask a question, develop custom study guides, or explore how course concepts depend on one another through interactive concept maps. Creating this as a customized local pipeline rather than relying on a commercial study system or a cloud-based retrieval-augmented generation approach like Gemini’s Notebooks gives me complete flexibility to create and modify my own study tools, without worrying about releasing potentially copyrighted material to a third-party.

Prepare the materials

preserves equations, figure descriptions, and page references; handles shorter documents and handwriting.
flags suspicious extracted text and compares it with source images before changing it.
turns lecture recordings into study notes. Reliable references from each concept back to its exact moment in a video remain unfinished.

Find an explanation

uses retrieved passages to answer a question with references I can open and check. I can save an answer or a session recap as a study note; can return to its recorded passages to develop the explanation further.

uses the shared source material to map relationships between ideas, including the assumptions that make a conclusion follow. Its first full graph covers part of a microeconomics course. A graph helps trace those dependencies; a guide explains a topic in sequence. Both contain drafted material that needs review.

Study and practice

starts from a topic list, selects indexed sources, drafts a guide, and proposes edits for review. Its optional enhancement step adds the same fuller explanations and worked examples available to an existing summary.
gives hints and feedback on an attempt. The separate tracks progress during a conversation, but its strict checks have struggled with teaching unfamiliar material.
keeps my reasoning, agent derivations, and tutoring work distinct for comparison.
stores extracted exercises with their provenance. currently retrieves its own style examples; integration with that stored bank remains separate work.
can accompany an explanation, while turns notes into spoken episodes. A generated chart or recording still needs checking for its intended use.

Maintain the collection

keeps working notes available across devices. reports missing or stale outputs for review, and helps prioritize the next work.

The links to each tool’s current evidence and limits. A useful study session still involves choosing the material, checking coverage, and comparing generated explanations with their sources. The shared source trail makes those checks possible; it does not settle whether an explanation is correct.

AI Research Assistant

Tue, 01 Sep 2026 00:00:00 +0000

AI Research Assistant brings paper discovery, document conversion, and search into the same research workflow. It can compare candidate abstracts with a description of my research question before trying to obtain the full articles. Converted papers can then be searched alongside my own research notes using the tools developed for Academic Hub.

For an illustrative research question such as “How do researchers measure displacement after a disaster?”, the starting point is more specific than a keyword search for disasters. I can ask the discovery tool to favor empirical measurement over policy commentary, then inspect the candidates before building a reading collection.

The three current tools handle different parts of that work:

. Search an academic-publication catalog by researcher or topic, then score abstracts against the research description using a model running locally. The tool tries several sources for full text and records papers that need manual retrieval. Finding a relevant paper does not guarantee access to it.
. Convert available PDFs to text with references back to their pages. The converter reuses the course-notes tools, choosing local extraction or AI transcription according to the document. Equations, figures, and imperfect extraction still need checking.
. Convert Word documents, including research ideas and application essays, while retaining headings and basic formatting. Their text and the papers enter the same search catalog, making it possible to look for a topic across both.

The shared can query the research collection and together. can use those retrieved passages for an answer with source references. Each collection keeps its own records, so a paper, my research note, and a lecture explanation remain distinguishable when they match the same question.

These tools support a literature review that I direct: choosing the question, reviewing papers, obtaining restricted articles, and interpreting the evidence remain part of my work. The give the current capabilities and limits of each stage.

Turning Dense Math Notes into Commute Podcasts

Thu, 01 Oct 2026 00:00:00 +0000

I built the to make course notes available away from a screen. Reading a mathematical document aloud requires more than sending its text to a speech engine: formula commands need to become spoken language first. As an illustrative example, E[X] should become “the expected value of X,” not a recital of brackets and formatting commands.

The first complete recording exposed a different problem: it was three hours and 22 minutes long. Generating a valid MP3 had solved file production, but left navigation through a long set of notes unresolved. I changed the output to separate episodes grouped around headings, with an index showing which sections went into each file.

This October 1, 2026 post describes the September development run. The dated update below separates later changes from that result.

Translate the notation before speaking

Simple replacements left too much raw formula syntax behind. A local model could rewrite the notation, but the recorded test on a roughly 122,000-character note took about six hours. The next version sent mathematical passages to cloud models while leaving plain prose alone. Cleanup and speech synthesis stayed local.

The amount of notation determined which model handled each passage. Shorter requests could run concurrently, and a later change let sections share one dispatch queue rather than waiting for each section in turn. That brought preparation of the narration text to 3.8 minutes in the September 9 run.

Separate preparation from production

Speech synthesis took another 19.4 minutes with three local Piper workers. The complete run therefore took 23.2 minutes and produced nine files. Those numbers describe one difficult input, not how long every course’s notes will take.

The episodes targeted 10-20 minutes, but one section with no internal headings became an episode of about 62 minutes. The result was not nine uniformly short recordings. It also did not establish whether listening would help me understand or retain the material; that needs listening and content review, beyond generating files.

Regeneration works at the source-file level: the saved state uses a fingerprint of the whole note. Editing any part regenerates all its episodes, while unchanged source files can be skipped.

Update, October 16, 2026: the current code can divide oversized sections at paragraph boundaries, following an October 10 fix. One indivisible paragraph can still exceed the target, and a new listening check is needed to assess the changed output. The saved narration text provides a way to inspect formula rewrites before relying on the audio. The covers output locations, textbook behavior, and the remaining limits.

Tutor Diagnosis & Hint Generator

Mon, 28 Sep 2026 00:00:00 +0000

A correct conclusion can hide a gap in the argument, while an otherwise sound attempt may use a method the course has not introduced. Tutor Diagnosis examines those differences separately: whether the result is right, whether the steps are justified, and whether the explanation fits the course’s definitions and methods. Its scores are model feedback for review, not instructor grades.

The tool can also give a hint before I have a full attempt. It searches course material for a useful direction and aims to leave the final derivation to me. When the available passages do not cover the topic, it labels a general hint instead of attaching an unsupported course reference.

An illustrative learning loop, not a transcript or a new test result:

Claim: Every even integer is divisible by four.

Attempt: It works for 4 and 8, so it must hold for all even integers.

Hint: What would you need to check beyond those two examples?

Revision: Two is even but not divisible by four. One counterexample disproves the claim.

The point is to identify the reasoning gap: examples that support a claim do not establish that it holds in every case. For course problems, the tool compares an attempt with a reference answer and retrieved passages, then names the most important gap to revisit.

A fresh solution for comparison

A separate solver receives the question without the tutor’s earlier answer or the source passages used to write it. In a recorded econometrics trial, this second solution identified an intercept condition the first answer had omitted. The user still compares both arguments; agreement or disagreement is not automatically resolved into a verdict.

Other recorded checks included identifying an intentionally flawed regression argument and producing a hint on a microeconomics problem without a final derivation. Those are limited examples of the workflow, not evidence that feedback will be accurate on every assignment.

Course-scoped logs preserve attempts, hints, feedback, and solution comparisons for later summaries. The describes the trials. This is a set of tools within ; the separate tracks an interactive session and applies different conversation rules.

Audio Generator

Wed, 09 Sep 2026 00:00:00 +0000

Audio Generator turns course notes into MP3 episodes for listening away from a screen. Mathematical notation needs an extra step: a speech engine can read words, but raw formula commands often sound unintelligible. The tool rewrites that notation into spoken language before synthesizing the recording.

For an illustrative translation, E[X] becomes “the expected value of X.” Denser equations need more than symbol replacement to preserve what the expression means. The pipeline sends math-heavy passages to a cloud model for that rewrite, while text cleanup and speech synthesis run locally. Plain prose can skip the model call.

Notes are split into episodes targeting 10–20 minutes. The current code can divide oversized sections at paragraph boundaries; one indivisible paragraph may still exceed the target. Textbook inputs follow a different path and currently produce one MP3 per source file. Editing any part of a note regenerates all of that file’s episodes; unchanged sources can be skipped.

The September 9, 2026 stress test used one equation-dense, roughly 122,000-character note. It took 3.8 minutes to prepare the narration and another 19.4 minutes to synthesize speech, producing nine files in 23.2 minutes overall. One episode was about 62 minutes long. That historical result predates the paragraph-splitting fix; a new listening test is needed to judge the revised output.

The local model tried earlier took about six hours on the same difficult input. Cloud rewriting reduced the wait but introduced API cost. Its speed does not establish that every formula was explained correctly, so the saved narration text provides something to inspect before relying on the audio.

and now exist, but an automatic weekly-summary-to-audio workflow is not established. Notes audio is stored with the larger course resources, outside tablet notes sync. The describes current output and regeneration behavior.

Problem Corpus Extraction

Sun, 06 Sep 2026 00:00:00 +0000

A useful practice collection needs more than a list of questions: it needs to say where each question came from and what kind of answer accompanies it. Problem Corpus Extraction gathers exercises from course materials and preserves that distinction. A student’s handwritten attempt stays labelled as an attempt.

That choice came from inspecting the available materials. Some exercises had no answer; others had the student’s working beside them, with no basis for calling it an answer key. The stored records therefore mark accompanying text as a student attempt or leave the solution absent. The extractor does not turn an unverified derivation into a verified one.

A clearly illustrative card, rather than an excerpt from private coursework:

Question: Show that the sum of two even integers is even.

Source: Example worksheet, Question 2.

Accompanying work: Student attempt, not checked.

The tool first detects numbered question boundaries, then asks a model to separate each statement from any accompanying solution and assign a short topic label. It stores the results by course and skips unchanged files on later runs. A failed extraction can be recorded without discarding other successful questions.

A September 2026 math-camp run produced 196 records from eight problem-set files, with no reported extraction failures. Four slide files had no recognized numbered-question boundaries and were skipped. That is evidence of the run’s output, not an accuracy audit of all 196 statements or solutions.

The current tool stops at creating the stored collection. Connecting it to remains separate work; that generator currently retrieves its own examples. The explains the output and provenance rules.

Problem Generation Sub-Agent

Sun, 06 Sep 2026 00:00:00 +0000

Extra practice is most useful when it exercises the method I am trying to learn. Problem Generation uses examples from my course to draft a new question and worked solution, then checks two things separately: whether the solution is mathematically valid and whether it uses the requested technique. A correct proof by a different method may miss the point of the exercise.

That distinction came from actual trials. A model asked for a proof using explicit error bounds, known as an epsilon-delta argument, kept using a different approach from its retrieved examples. Splitting the review into “requested technique” and “correctness” caught those mismatches, although the local model still failed to produce an accepted answer in two full trials. The check exposed a limitation; it did not make the model capable of solving the task.

An illustrative request makes the difference easier to see:

Practice question: Show that the sequence 1/n approaches zero.

Requested method: Use the definition of convergence.

Solution sketch: For any positive error tolerance ε, choose an integer N greater than 1/ε. Whenever n is larger than N, the distance 1/n from zero is less than ε.

Checking the sketch means inspecting both the inequalities and the use of the definition, rather than accepting a graph or a bare statement of the limit. This is an invented demonstration, not a transcript of a generation trial.

Course examples guide the draft

The finds problem-set passages for style and difficulty, plus textbook passages when available. The generator will not proceed without style examples, but can work without textbook passages. A weakly related style match can also pull the draft off topic; the closest available example is not necessarily a suitable one.

Generation now defaults to Gemini, with API cost. In the September 6, 2026 comparison, nine trials across three constrained topics passed the model checks and recorded manual review, while the local alternative had struggled with the requested method. That narrow result motivated the default; it does not establish reliable mathematics across a course. Local generation remains optional.

The second check is another model call, so it can repeat the first call’s mistakes. Earlier trials accepted flawed reasoning, including a circular argument. Rejected attempts can be revised within a bounded retry loop, but students still need to inspect the result.

The separately extracted is not yet connected to this generation loop. Current examples come through passage retrieval. The documents that distinction and the generation options.

Video Lecture Notes

Sun, 06 Sep 2026 00:00:00 +0000

A lecture series can contain several explanations of the same idea, spread across videos with unhelpful titles. Video Lecture Notes downloads the audio, transcribes it, and combines related lectures into study notes that can be searched alongside textbooks and handwritten notes. The combination step matters: it tries to turn a sequence of recordings into one explanation rather than leave a separate transcript for every file.

One trial exposed a surprisingly basic limit. A three-video group produced a note reflecting only one video’s content because the local model was receiving only the end of the combined transcript. The shared model helper now requests enough context for the prompt. Rechecking showed better coverage and structure, although reliable links from each concept to the exact video moment remain unfinished.

From recording to study note

Audio download, speech transcription, and note synthesis run locally. The transcript retains timed segments; the synthesis model receives them when drafting the combined note. Registering that note with the uses the existing classification and embedding API calls, so the full searchable workflow is not entirely offline.

Grouping first uses playlist context and recognizable lecture-series titles. When that context is insufficient, it can compare transcript contents. This saves manual sorting, but shared vocabulary is not the same as belonging to the same lecture: the recorded trial grouped some differently numbered videos together and split another lecture’s two parts.

For an illustrative output, a note might organize “Sets and functions” into definitions, examples, and a comparison of related ideas. That describes the intended format, not an excerpt from the recorded run. To check an explanation, I still need the recordings and transcripts; a general video link at the end is less useful than a precise reference beside the claim.

What the trial covered

The September 2026 record covers eight videos from a 105-video Math Camp playlist, across two passes. They produced five indexed notes. That establishes a working download-to-note path on a subset, not full-playlist coverage or complete retention of every explanation.

Long groups remain expensive to synthesize on CPU hardware, and the remaining timestamp and grouping issues affect practical review. The and linked status record distinguish the implemented workflow from those open checks.

Visualization Sub-Agent

Thu, 03 Sep 2026 00:00:00 +0000

A formula for gradient descent describes repeated steps toward a minimum. A picture can show what those steps do: the prepared example in this tool traces a path across the contours of a bowl-shaped surface toward its center. I can zoom in and inspect the points alongside the written explanation, rather than infer the whole path from the update rule.

The important distinction is how that picture is made. A small library covers familiar concepts with prepared Plotly charts, which run without a chart-generation model call. For other topics, the tool asks a model to write chart code using the question and retrieved course passages. That opens up more concepts, but introduces another judgment: a script can run successfully while illustrating the wrong idea.

A plot beside the answer

Visualization is optional within . A report can combine the question, answer, source references, and interactive chart in one HTML file. If chart generation fails, the text report can still be produced. A recorded September 6, 2026 trial combined a , its solution, and an embedded interactive plot in the same report.

Generated charts currently use Gemini by default, with API cost. Local Ollama generation is an explicit alternative, but it timed out or produced broken scripts in the recorded comparison. Gemini succeeded twice on the same request. Two successes are useful evidence for that change of default, not a broad chart-accuracy evaluation.

Running code is one check

The tool executes generated code with a time limit, a separate working directory, and an environment that excludes inherited API secrets. Execution errors can be returned to the model for a bounded retry. These measures limit particular failure modes; the process is not a comprehensive security sandbox.

Past scripts that ran successfully can be offered as examples to later generation. They stay separate from the prepared templates because successful execution alone does not make an example mathematically correct. Whether that small example store improves results over sustained use remains unmeasured.

Template matching also needs care: “convergence in probability” should not receive a generic series-convergence plot just because both contain the same word. Inspecting what the chart represents remains part of using it. The explains templates, generation, and the execution limits.

Journal Discovery Pipeline

Wed, 02 Sep 2026 00:00:00 +0000

A search for “disaster resilience” can return papers about infrastructure, recovery, public health, or business continuity. Journal Discovery lets me specify the angle I want, then compares that description with candidate abstracts before trying to download anything. The comparison runs locally, helping narrow a broad literature search without asking a language model to judge every paper.

The October 15, 2026 trial makes the stages concrete: a disaster-research query retrieved 60 candidates, accepted 15 as relevant, and downloaded seven PDFs. Eight accepted papers still needed manual access. Finding a candidate, obtaining its full text, and reading or evaluating it are separate accomplishments; the pipeline handles the first two only within the available access routes.

Grow a library around a question

The starting point can be a topic or a researcher’s name. OpenAlex, an academic works catalog, supplies candidates and bibliographic information. A locally computed representation of each abstract is compared with my relevance description. When an abstract is unavailable, title-based scoring is a weaker signal; names and subject labels also need judgment.

A citation-following mode offers another route: find newer papers citing material already in the library, review the proposed list, then fetch the selected papers. A citation alone never authorizes that download step or establishes relevance.

The downloader tries open-access sources and the configured institutional route. If a publisher requires ordinary browser access, the paper goes onto a linked manual-download list. I use my library access in the browser and save the PDF; the tool does not solve publisher access challenges. Downloaded files are checked as PDFs and written through temporary files so an interrupted transfer does not leave a partial final file.

Discovery is upstream of reading

separately converts and indexes the files. Reconciliation can recognize manually saved papers by their converted contents, rather than depending on filenames.

Two maintenance operations have different authority. The older metadata audit can automatically reconcile mechanical folder and tag differences against its reference data, while flagging title or author mismatches. The newer classification mode uses stored OpenAlex Topics to propose folder and tag decisions for human acceptance. It is not an automatic reading of each paper’s argument.

Direct inspection found the 15 accepted disaster papers on topic in that trial; a separate author query accepted six and downloaded one. Those are limited runs. Converted chart descriptions may also omit plotted values, so later search results still need checking against the PDF. The and linked October status record give the current workflow and evidence.

Journal Article Transcription

Tue, 01 Sep 2026 00:00:00 +0000

Finding a paper is only the start; later I need to locate the argument, method, or result inside it. Journal Article Transcription converts available article PDFs into searchable text with references back to their pages. A paper’s contents can then appear beside my research notes in a search result.

The converter reuses the same machinery as the . Clean digital text can be extracted locally; harder pages need transcription from their images. The current default prepares task cards for an agent working through my subscription, then validates submitted work before writing and indexing it. Search summaries and embeddings still use API calls, even on that transcription route.

A separate metered-API route remains available. Pending agent work stays pending unless API fallback is explicitly requested; it is not silently sent for paid transcription. Very long documents are flagged for a person’s decision rather than automatically sent to the more expensive textbook converter.

The older September 2026 trial converted and indexed three distinct papers. A fourth file was an exact duplicate, and a topic query found the relevant papers alongside the essay collection. Those results establish the earlier conversion-and-search path; they are not a new live trial of the subscription task-card workflow.

Page references make checking easier, but converted prose cannot preserve everything a figure communicates. Equations, chart labels, and extraction errors still deserve comparison with the PDF.

PDFs can come from or files I add myself. Conversion registers their text with the ; brings Word documents into that same collection. The describes the task-card and API routes.

Research Notes Conversion

Tue, 01 Sep 2026 00:00:00 +0000

An old research idea is easier to revisit when I can find it beside the papers that discuss the same topic. Research Notes Conversion brings Word essays and research notes into that search collection. It reads the document’s existing headings and formatting directly, so the conversion itself needs neither image recognition nor an AI model.

Finding a passage also needs a useful locator. Word documents do not carry the PDF page markers the search tools originally expected. The indexer now uses headings where available and paragraph numbers as a fallback, so a short note can be cited without inventing a page number.

For an illustrative conversion, a heading such as Research idea and its following paragraphs become a heading and ordinary text in the searchable version. A reference such as Paragraphs 4–6 tells me where to look within that note. This demonstrates the format, not an excerpt from my private writing.

The original Word file stays in place. Conversion creates a Markdown copy, retaining headings, emphasis, and lists. Optional registration with the adds a catalog description and a representation used for search, using API calls; conversion alone remains local.

Reusing the course-material indexer exposed a useful mismatch: its original document labels tried to classify personal essays as textbooks or handwritten notes. Giving the research collection its own vocabulary fixed that distinction. Search also keeps each result’s collection identity, so two folders both named “notes” cannot be confused merely because their names match.

The early validation used 19 essay and research-note files. After the classification and locator fixes, topic queries could search this collection and Academic Hub together, returning relevant material from the appropriate sources. That is a limited recorded trial, not evidence that every query will find everything relevant.

The converter still works on selected local files. Direct Google Drive ingestion and a complete literature-review workflow are beyond its current interface. adds papers to the same search infrastructure; the documents conversion and indexing options.

RAG Analysis

Sun, 30 Aug 2026 00:00:00 +0000

RAG Analysis answers a question using passages found in my textbooks and course notes, with references back to the material it used. That lets me inspect an explanation and continue reading at its source. The reference is a starting point for checking the answer, not a guarantee that the model interpreted it correctly.

One useful choice is limiting how many passages a single file can contribute. Otherwise, a relevant textbook can fill the available space and crowd out lecture notes or another author’s explanation. Follow-up questions are also rewritten using the recent conversation, so “explain that differently” becomes a specific question the search tools can use.

A clearly illustrative example, rather than a quotation from a recorded answer:

Question: What does the spectral theorem help explain about a real symmetric matrix?

Answer sketch: It gives perpendicular directions along which the transformation acts by scaling, making its action easier to describe.

Reference format: Section 7.4, pages 264–266.

The name RAG means retrieval-augmented generation: find relevant passages first, then supply them to the model writing the answer. This project reuses the for that search. An August 2026 trial answered a spectral-theorem question using two source files; a follow-up exchange also exercised the conversation-based search step. Those were specific trials, not a broad evaluation of answer accuracy.

What is remembered

The running chat retains its conversation, but restarting the process does not restore the full dialogue. With a course selected, the tool can save answer, hint, draft-feedback, and verification events. Recent recorded learning gaps can inform later answers, and a session recap can turn the recorded discussion into a study note.

Requesting a report also saves the answer as a note with its source references. Those references identify the passages in the , so can reopen that material and develop a short answer into fuller explanations and examples. The offers another starting point when I already have a topic list. Saved notes and logs survive separately from the live chat history.

A companion resolver answers question markers in handwritten notes. Its recorded seven-question run included four source-grounded answers and three marked as ungrounded. General answers remain leads to check, and retrieving a handful of passages is too narrow to establish comprehensive coverage of a week’s study.

The describes the current interfaces. adds feedback on an attempt; the separate manages an ongoing tutoring session.

Source Indexer

Sun, 30 Aug 2026 00:00:00 +0000

A question about eigenvalues might belong with a textbook proof, a lecture explanation, or an exercise I have already attempted. Source Indexer searches converted course materials in two stages: first finding promising documents, then locating passages inside them. The result includes a heading, page, or paragraph reference so I can continue reading where the match came from.

The search catalog has a record for each document, much like a library card with a brief description and subject labels. These descriptions help find material; the longer summaries I study are written by the answering and guide tools. A record’s identity comes from the source file’s contents rather than its filename, so renaming a PDF does not have to create a new document. Course-level records narrow the search before it compares individual files.

Give other study tools something to read

The and converters register their outputs with the indexer. Search uses document descriptions, subject labels, and numerical representations of meaning to rank related material, then returns excerpts from selected documents. PDF-derived passages can carry page references; Word-derived notes without page markers can use headings or numbered paragraphs instead.

Several study tools use that foundation:

retrieves passages for a question and records their references with the answer. can reopen the exact passages saved with a study summary to develop it further.
selects indexed sources for a topic list, then drafts and revises a longer guide.
retrieves evidence for explanations and connections, including the conditions a theorem needs.

The same search infrastructure supports , keeping their collection identities distinct from course materials. Each downstream tool still has to interpret the passages it receives.

Similar subjects are not always duplicate notes

A lecture may exist as handwriting alone and as a later version with slides pasted beside the same handwriting. Searching both can crowd out other useful sources. Whole-document similarity was too broad to distinguish these pairs from different lectures on the same subject. The subset linker instead compares short word sequences from the handwritten portions, then hides the smaller version when its fuller counterpart survives the search. Both remain accessible.

Links across different years of a course are another feature. The tool reuses existing document comparisons to identify related material, with uncertain matches held for review. That supports revisiting an older explanation without claiming every note has already been matched correctly.

An early August 2026 checkpoint recorded 30 healthy document cards in one course, with 14 subject labels. Those are historical catalog checks, not current totals or a measure of search accuracy. Dense proofs and narrative notes can still need different passage boundaries. can report missing or stale outputs, but its available repair is narrowly scoped rather than a general automatic cleanup. The describes the catalog, search, and linking behavior.

Notes Post-Processing

Fri, 28 Aug 2026 00:00:00 +0000

A square-root sign once became the letter p in my extracted notes. The text still looked printable and ordinary, so the initial checks let it through. Notes Post-Processing was built to catch that kind of plausible-looking error after transcription, then compare it with the original page before making a correction.

Context on both sides of a symbol mattered. Looking only at the text before the corrupted character missed evidence that appeared afterward; a second local model could use that surrounding context to judge which positions deserved attention. The models flag candidates rather than deciding what the source must have said.

The recorded motivating run repaired that square-root error on page 6 and left nine other flagged candidates unchanged. The notation below illustrates the difference:

Extracted text	Corrected reading
`p(h² + k²)`	`√(h² + k²)`

The tool first identifies suspicious text using structural checks and local language-model scores. Surviving candidates go to an image-based comparison with the PDF page. It records whether the page was changed, left alone, or could not be verified.

Testing across more notes exposed another problem: legitimate mathematical language can look unusual to a general language model. Joined words from an upstream spacing error also produced many false alarms. Fixing the spacing and tuning the checks reduced unnecessary flags, but did not eliminate them.

False positives consume review time and image-checking calls. Comparing with an image supplies additional evidence; the model can still misread that evidence or make a bad change. Corrected material therefore needs spot checks rather than being treated as automatically clean.

This tool follows and helps improve material used by the . The describes the reproduced error and broader precision limits.

Notes Transcription Pipeline

Thu, 27 Aug 2026 00:00:00 +0000

A question scribbled beside a lecture slide is easy to lose in a folder of drawings. Notes Transcription turns handwritten canvases and short course PDFs into searchable text, keeping references to the original material. It also separates pasted slides from handwriting, so later study tools can tell which explanation came from the lecturer and which note I added.

Typed PDFs need care too. A small raised character can carry the difference between R² and R2, yet ordinary text extraction may flatten them into the same line. The pipeline uses character size and vertical position to recover exponents and subscripts locally before deciding whether a page needs AI transcription. That preserves useful structure without paying a model to reread every clean page.

Once the output is registered with the , its passages can be found alongside textbook material. That is what lets the draw on a handwritten explanation, or cite course notes behind a proposed connection. Transcription prepares the material those tools read.

Choose how much of the source needs rereading

The PDF path uses three levels of work. Clean digital text can be extracted locally. If only a few pages look defective, those pages receive image-based repair with neighboring text for context. Handwriting, difficult exports, or documents with widespread defects need fuller transcription. Some note-taking exports can omit entire equation regions from their text layer, so an apparently clean extraction is insufficient evidence for trusting them.

The recorded August 2026 comparison checked recovered exponents and subscripts across 13 pages from two documents against existing transcriptions. In one 43-page problem set, the local improvements reduced the detected defect rate from 63% to 5%, leaving two pages for repair. Those results concern the checked notation and routing decisions, not the accuracy of every word in the collection.

Drawings and PDFs take different paths

Excalidraw saves its SVG images automatically. The canvas path cuts a tall drawing at whitespace gaps, transcribes the pieces with some preceding context, and produces both a raw transcript and an expanded note for search. Expansion adds prose and can introduce interpretation; the raw version and source drawing remain important for checking it. Handwritten questions can be marked for a separate answering tool.

The current command-line workflow can prepare page images and task cards for a subscription agent, then validate the submitted cards before writing the usual outputs. This is a manual handoff. The metered API path is also available, and search indexing has its own API calls; running the scripts locally does not mean all processing stays on the device.

Supported sources here are PDFs and Excalidraw scenes with exported images. Word-produced PDFs fit the PDF route; native Word documents are a separate conversion task. Most importantly, plausible-looking errors can survive transcription. checks suspicious text against source images afterward, while the explains the available routes.

Marker PDF Conversion

Wed, 19 Aug 2026 00:00:00 +0000

Finding a word in a textbook PDF does not necessarily find the argument around an equation or the information inside a diagram. Marker PDF Conversion prepares those books for the study tools in Academic Hub: searchable text, mathematical notation, extracted figures, and references back to the source pages. A separate description pass makes figures easier to find through text search too.

Where a long book is divided matters. A fixed page limit can cut through a table or a proof, so the converter looks for chapter boundaries in the PDF outline or printed contents first. It also distinguishes the PDF’s page position from the page number printed in the book. That lets a reference such as “see page 157” remain useful even when a preface has shifted the file’s numbering.

The makes the converted material available as referenced passages. A can then select a textbook section for an explanation, while a can cite evidence for the conditions linking two ideas. Preserving the book’s structure gives those later tools something specific to read and cite.

Rent the hardware for the batch

Marker is an open-source tool for recognizing text and page layout. Here it runs on a temporary graphics-processing machine in Google Cloud, which provides the computing capacity needed for dense books. The model loads once for a batch rather than starting again for every title. Converted files return locally before the temporary machine and disk are removed; keeping an idle disk would continue to cost money.

This is the heavier conversion route. Short documents and handwriting use instead. The inputs are source PDFs I am authorized to process for my own study; the website does not distribute those books.

Keep the source available for comparison

In the recorded four-book check, printed-page labels were recovered for roughly 96-98% of pages, with no duplicate internal anchors. That is encouraging coverage across those layouts, with gaps still requiring the PDF page reference. It does not establish that every formula or cross-reference was transcribed correctly.

The separate figure pass described 764 of 793 candidate images across five books, skipping 29 as decorative. Its derived text leaves the original conversion intact. Descriptions make a chart discoverable but cannot replace examining its axes, values, or visual argument in the source.

Before spending GPU time, duplicate checks can reuse an existing conversion. Less certain matches remain subject to review. Recovery from memory failures also has a documented retry and escalation policy, tested separately from the content checks; those tests do not establish reliability across every cloud interruption.

The covers operation and costs. The page’s linked status records document the conversion, chapter, and figure trials.

Introducing Academic Hub

Tue, 18 Aug 2026 00:00:00 +0000

Like any knowledge intensive task, taking a graduate course combines multiple sources of information in various formats: textbooks, lecture notes, presentation slides, problem sets, Youtube video explainers, old exams, and relevant research papers. The standard approach to combining these materials is haphazard, with relevant info spread across each category and only loosely connected by topic–any given section of a syllabus might connect to half a dozen textbook chapters, meaning students spend a lot of time just finding the right source. If a topic depends on pre-requisite knowledge which the student is unfamiliar with (a common issue in my PhD program so far), looking back through foundational textbooks for the right content takes longer than learning the idea. When it comes time for exam review, notes are only loosely connected to problem sets and lecture slides, and none of these are linked to practice problems or prior exams. In short, students spend far too much time categorizing and retrieving relevant information, distracting from higher value learning processes, shifting pedagogical focus from the actual ideas to the mechanics of how different authors organize and refer to those ideas.

My solution for my own coursework was the . If all my materials could be converted to the same plain-text format, then organizing them into a searchable database with relevant categories and connections would be an easy task for any language model. As I developed methods to convert a larger variety of information sources, the potential applications for learning became more and more useful: from that automatically answers my handwritten sidebar questions from lecture to more relevant study guides and , tailored to the specific topics which came up often in past exams, and even multi-round that can help break down complex problems without revealing solutions.

Most of these applications could be replicated with a standard online AI model, but the default agents lacked the context of my specific courses. Retrieval-augmented generation (RAG) models that can train on or incorporate specific files to produce more relevant answers are available, but dropping whole PDFs into a system like a Gemini Notebook is very token expensive, they waste most of their compute just processing inputs. By front-loading the transcription and indexing process, then standardizing it across my courses, I can run any type of LLM agent (subscription based, local, or API) and get highly relevant results based on my exact materials, with citations to source context, at a fraction of the cost. The more source materials I included, the more summaries and problem sets I generated, the better the collection becomes; by the end of the semester, I could just say “looking back at my previous notes and homeworks, help me review this section” and I could create much more useful review materials with far less effort.

Converted materials provide a shared source collection for several study tools; their outputs still need review.

The Academic Hub pipeline is completely reproducible too. Each step is modular, so when I found that my initial transcription approach (using Gemini API credits) was becoming too costly, I was able to switch out specific steps with a subscription-based model (or a local GPU-based model). Applying the entire range of tools to a new course is as simple as dropping in a folder of old notes, slides, and problem sets. Courses can build on each other, so if a topic from Microeconomics I comes up again in Micro II, all of my previous notes can be used to inform the new questions and help me review. Once large PDFs are converted to markdown text files, the storage requirements are minimal–I can to my tablet via GitHub and Obsidian.

While I built it to help study for courses, the processes involved can be applied to any type of knowledge base, from research papers to government reports. I’ve already started expanding the pipeline to academic research, to automate literature reviews and create a structured database of international development interventions and outcomes. I’m eager to expand the features for both and start applying them at a larger scale, including user testing to see if the tools are accessible to those without extensive backgrounds in computing, AI, or knowledge management.

If you have an interesting use case you’d like to try, or just want to discuss the development process, please reach out to me by email at or . All of the code backing up the Academic Hub is available as part of my larger AI-Sandbox project and each subproject has more details in the . I welcome any questions or feedback as I continue to develop this project!