scraper01's comments

I was trying to get up to speed on a new topic for a project and got really tired of juggling a dozen PDFs. You know the drill: download, skim, lose track of which paper had that one good paragraph, repeat. So I hacked together a little Streamlit app to help with this. Basically, you give it a topic and some websites (like arxiv), and it tries to find and download a bunch of PDFs for you. Then it chews on them for a while and gives you a chat box so you can ask questions about the stuff inside.

The tech part that might be interesting: I didn't want to do just a basic vector search on text chunks. I'd read the RAPTOR paper and thought it was a cool idea, so I tried to implement it. It recursively clusters the text chunks and then uses an LLM to summarize each cluster, building up a tree. The hope was it might give more high-level, synthesized answers. The whole multi-step process is held together with LangGraph. It's pretty rough right now. PDF parsing is a nightmare, as usual, so it probably messes up on papers with complex layouts. And the indexing part is kinda slow if you give it a lot to read. It works with local Ollama models or Gemini if you plug in an API key.

I don't have a live demo up because the indexing would probably cook a cheap server, but it should run locally without too much fuss. I'm posting it here mostly to see if this is a problem anyone else has, and if the way I'm trying to solve it makes any sense. If you end up trying it, I'd love to know what breaks or what you think would make it more useful.

The code's here: https://github.com/andres-ulloa-de-la-torre/deep-search-acad...

Thanks.

Hey everyone.

I've been looking into a fundamental problem in modern AI. We have these massive language models trained on a huge chunk of the internet—they "know" almost everything, but without novel techniques like DeepThink they can't truly think about a hard problem. If you ask a complex question, you get a flat, one-dimensional answer. The knowledge is in there, or may i say, potential knowledge, but it's latent. There's no step-by-step, multidimensional refinement process to allow a sophisticated solution to be conceptualized and emerge.

The big labs are tackling this with "deep think" approaches, essentially giving their giant models more time and resources to chew on a problem internally. That's good, but it feels like it's destined to stay locked behind a corporate API. I wanted to explore if we could achieve a similar effect on a smaller scale, on our own machines. So, I built a project called Network of Agents (NoA) to try and create the process that these models are missing.

The core idea is to stop treating the LLM as an answer machine and start using it as a cog in a larger reasoning engine. NoA simulates a society of AI agents that collaborate to mine a solution from the LLM's own latent knowledge.

It works through a cycle of thinking and refinement, inspired by how a team of humans might work:

The Forward Pass (Conceptualization): Instead of one agent, NoA builds a whole network of them in layers. The first layer tackles the problem from diverse angles. The next layer takes their outputs, synthesizes them, and builds a more specialized perspective. This creates a deep, multidimensional view of the problem space, all derived from the same base model.

The Reflection Pass (Refinement): This is the key to mining. The network's final, synthesized answer is analyzed by a critique agent. This critique acts as an error signal that travels backward through the agent network. Each agent sees the feedback, figures out its role in the final output's shortcomings, and rewrites its own instructions to be better in the next round. It’s a slow, iterative process of the network learning to think better as a collective. Through multiple cycles (epochs), the network refines its approach, digging deeper and connecting ideas that a single-shot prompt could never surface. It's not learning new facts; it's learning how to reason with the facts it already has. The solution is mined, not just retrieved. The project is still a research prototype, but it’s a tangible attempt at democratizing deep thinking. I genuinely believe the next breakthrough isn't just bigger models, but better processes for using them. I’d love to hear what you all think about this approach.

Thanks for reading.

I've been looking into the idea of "deep thinking" in AI, but it seems reserved for big models with huge compute budgets. I wanted to see if a different approach was possible: trading instantaneous computation for a slower burn. To explore this, I've been building an open-source research project called Network of Agents (NoA). The goal is to turn a modest laptop (I'm developing on a 32GB RAM machine) into a "solution mining" rig. You can set up a hard problem, and using a local LLM (via Ollama and a quantized Qwen model like Qwen 30b a3b), let a society of agents work on it for hours or days, iteratively refining their collective answer. The Core Idea: Backpropagation with Natural Language The system is built with LangGraph and is inspired by neural networks. It runs in epochs, with each epoch consisting of a "Forward Pass" and a "Reflection Pass". 1. The Forward Pass (Inference): • Instead of numerical weights, the network's "weights" are the natural language system prompts of its agents. • The process starts by procedurally generating a multi-layered network of agents. The first layer gets cognitive diversity from MBTI archetypes and "seed verbs" related to the user's problem. • Subsequent "hidden" layers are built by having an agent-analyst chain create a "hard request" designed to challenge the previous layer, then spawning a new agent specialized for that challenge. • Information flows through the network layer by layer, with the combined JSON outputs of one layer being broadcast as input to all agents in the next. • 2. The Reflection Pass (Learning): This is where I've tried to simulate backpropagation. • Critique as the "Loss Function": After the final layer's outputs are synthesized into a single solution, a critique_agent assesses it against the original problem and generates a constructive critique. • Propagating the "Gradient": This critique is the error signal. It's propagated backward through the network. An agent in layer N-1 receives a targeted critique based on its contribution to the final answer generated by layer N. • The "Optimizer" Meta-Prompt: At each step of the backward pass, an update_agent_prompts_node uses the incoming critique as the main input to a meta-prompt. This meta-prompt's job is to completely rewrite and evolve the receiving agent's system prompt—its skills, attributes, and even its career—to better address the critique.

The entire network learns and adapts its own instructions, not through a central controller, but through a distributed process of peer-to-peer challenge. The Long-Term Vision: A New Kind of Training Data This is the part that I find most exciting. Every run of this system produces a complete, structured trace of a multi-agent collaborative process: the initial agent personas, the layer-by-layer reasoning (CoT traces), the critiques, and the evolution of each agent's prompts across epochs. This is a new kind of dataset that captures the dynamics of reasoning, not just static information. My long-term, ambitious goal is to use this data to train a "World Language Model" – a model trained not just on text, but on the fundamental patterns of collaboration, error correction, and social intelligence. This is an early-stage research project. The code is available for anyone to run, and the immediate roadmap includes dynamic memory for small models, P2P networking for distributed mining, and better visualization. I'd love to get this community's feedback. What do you think of this approach? Is the analogy to backpropagation sound? How would you improve the meta-prompts that drive the evolution? Thanks for reading.