Neuron: a tool for your personal research

Your Autonomous Architect for a Living Map of Discovery

Comment

Neuron (Synapse)

Neuron was born from a practical and personal problem: during research, learning, and side projects, information grows faster than we can organize it. Papers, notes, code, logs, and AI chats accumulate quickly, but relationships between ideas remain fragmented.
As a result, it becomes hard to verify claims, track evidence, detect knowledge gaps, and decide what to do next.

Inspiration

The core inspiration behind Neuron was to transform passive note-taking into active, evidence-driven reasoning.

Most tools help users collect information, but very few help answer questions like:

  • Which claims are weakly supported?
  • Where do sources contradict each other?
  • What is missing in my current understanding?
  • What experiment or validation step should I run next?

Neuron is designed to bridge this gap: an AI-native workspace that structures knowledge into an Evidence-Linked Knowledge Graph and continuously audits it for gaps, conflicts, and opportunities.

The goal is to help learners and researchers move from information overload to decision-ready insight.

What it does

When users upload papers (PDFs), notes, or multimodal inputs, Neuron turns them into a living Evidence-Linked Knowledge Graph—not just a summary.

At its core, Neuron answers three questions:

  1. What is supported by evidence?
  2. Where are the gaps or contradictions?
  3. What should I do next?

Core capabilities

  • Evidence-Linked Graph Construction
    Parses documents into claims, concepts, methods, and relationships, then links key insights to source evidence spans for immediate verification.

  • Gap & Conflict Detection (The Auditor)
    Background agents continuously analyze the graph:

    • Logic Auditor: detects contradictions across sources
    • Socratic Auditor: asks critical questions about weak assumptions
    • Negative Space Auditor: finds missing but necessary links
    • Serendipity Engine: proposes cross-domain analogies for new ideas

  • Autonomous Architect
    Detects research gaps, proposes hypotheses, and generates executable next steps:

    • Python experiment code
    • YAML experiment configs
    • LaTeX proof drafts
    • GitHub-ready action artifacts

  • Traceable Evidence by Default
    Every major insight is tied to source anchors/hyperlinks for fast auditing.

  • Multimodal Knowledge Graph
    Converts text, images, video frames, and audio clips into connected nodes.
    Includes a Time-Travel timeline to replay how understanding evolves.

  • Deep Research Agents
    Users can delegate complex tasks to autonomous agents that plan, use tools (e.g., Google Search, ArXiv), stream reasoning logs, and produce actionable protocols.

  • Narrative Weaver
    Converts selected graph paths into coherent research narratives and draft writing.

Gemini Description

Neuron’s core intelligence is built on Gemini 3, and Gemini features are central to every stage of the product. For deep reasoning, we use Gemini 3 Pro with Thinking Config and a dedicated thinkingBudget.

  • This enables our research agents to plan, inspect intermediate reasoning, and self-correct before producing final outputs.
  • That behavior is critical for high-value tasks such as contradiction detection, gap analysis, and hypothesis design.

For real-time user experience, we use Gemini 3 Flash in the ingestion engine to rapidly parse large PDFs and notes into structured graph objects (claims, concepts, and links) with low latency. We also use Gemini’s multimodal capabilities to extract evidence from text, images, audio, and video frames and connect them inside an Evidence-Linked Knowledge Graph.

Finally, Function Calling allows Gemini to orchestrate external tools—such as web/literature search, Neo4j graph queries, and Python execution—so outputs are grounded in retrievable evidence.

How we built it

Frontend

  • React 19 + TypeScript + Tailwind CSS
  • Interactive graph UI for claim/concept relations
  • Real-time streaming UI for agent traces and outputs
  • Focus controls (layout freeze, path exploration, timeline playback)

Backend

  • FastAPI (Python) for async orchestration
  • Neo4j for graph-native relation storage (supports, contradicts, cites, depends-on)
  • SQLite for source anchors and evidence-span metadata
  • Event-driven pipeline for live multi-agent/UI synchronization

AI/ML Layer

  • Gemini 3.0 Pro (Thinking Config) for deep reasoning
  • Gemini 3.0 Flash for fast ingestion and background analysis
  • LangChain + Google GenAI SDK for agent routing and tool orchestration
  • Function calling for grounded protocol assembly

Challenges we ran into

  1. Hallucination vs. trustworthiness
    Preventing unsupported claims from entering the graph required strict evidence anchoring at the data-model level.

  2. Multi-agent synchronization
    Concurrent agents caused race conditions and UI inconsistency; we addressed this with event streams and stricter state transitions.

  3. Graph readability at scale
    Node growth led to visual clutter; we introduced timeline replay, focus filtering, and progressive disclosure.

  4. Time pressure
    With a tight deadline, I prioritized explainability over non-critical features.

Accomplishments that we're proud of

  • Self-Correction Loop
    Agents can detect flaws in their own intermediate reasoning, log a self-correction event, and revise strategy before final output.

  • Universal Protocol Generation
    Our Universal Action Engine detects domain context and outputs execution-ready artifacts:

    • Computer Science → runnable code workflows
    • Life Sciences → structured lab protocols
    • Mathematics → LaTeX proof drafts

What we learned

  1. Evidence-first design is non-negotiable.
    Verifiability must be built into the system, not added later.

  2. Agent orchestration needs structured outputs.
    Robust schemas and validation are critical for reliable tool use.

  3. Thinking time improves quality.
    Explicit reasoning budget significantly improves depth and coherence.

  4. UX matters as much as model quality.
    Transparency features (logs, evidence links, timeline replay) are essential for real workflows.

What's next for Neuron

  • Live Collaboration
    A shared workspace (Figma-like) where multiple researchers co-edit the same graph and collaborate with AI agents in real time.

  • Zotero / Mendeley Integration
    Bi-directional sync with citation managers, enabling one-click conversion of existing libraries into knowledge graphs.

Built With

Share this project:

Updates

Submission history