From 2 Hours to 10 Minutes: FrontierPilot - AI Research Assistant Powered by OpenClaw

Sorry bhai! Ekdom thik korlam. Nicche FrontierPilot er submission ta proper format e likhe dichi - shob gulo text block hishebe thakbe, kono extra formatting nei:

This is a submission for the OpenClaw Challenge.

What I Built

FrontierPilot is an AI-powered research assistant that helps researchers discover research papers from arXiv.

Users enter a research topic, select number of papers (5-50), and instantly get papers with titles, summaries, authors, and publication dates.

GitHub: github.com/md-azad46/frontierpilot

Features

🔍 Paper Search - Fetch 5-50 research papers by topic

📄 AI Summaries - Automatic abstract extraction

👥 Top Researchers - Find most active authors

🌐 Communities - Reddit, Discord, conference suggestions

📚 Learning Path - Beginner → Intermediate → Advanced

💾 Multi-Export - JSON, CSV, TXT, PDF download

🎨 Dark/Light Mode - Toggle theme

How I Used OpenClaw

The Problem Without OpenClaw

Normally, to fetch research papers from arXiv, I would need to write 50+ lines of complex code:

# Without OpenClaw - I have to do everything manually
import urllib.request
import urllib.parse
import xml.etree.ElementTree as ET

def fetch_papers(topic, max_results):
    # Step 1: Manual URL encoding
    encoded_topic = urllib.parse.quote(topic)

    # Step 2: Manual API URL construction
    url = f"http://export.arxiv.org/api/query?search_query=all:{encoded_topic}&max_results={max_results}"

    # Step 3: Manual HTTP request
    req = urllib.request.Request(url, headers={"User-Agent": "MyApp/1.0"})

    # Step 4: Manual error handling
    try:
        with urllib.request.urlopen(req, timeout=30) as response:
            data = response.read().decode()
    except Exception as e:
        return {"error": str(e)}

    # Step 5: Manual XML parsing (the hardest part)
    root = ET.fromstring(data)
    papers = []

    # Step 6: Manual data extraction
    for entry in root.findall("{http://www.w3.org/2005/Atom}entry"):
        title = entry.find("{http://www.w3.org/2005/Atom}title").text
        summary = entry.find("{http://www.w3.org/2005/Atom}summary").text
        paper_id = entry.find("{http://www.w3.org/2005/Atom}id").text.split("/")[-1]

        authors = []
        for author in entry.findall("{http://www.w3.org/2005/Atom}author"):
            name = author.find("{http://www.w3.org/2005/Atom}name").text
            if name:
                authors.append(name)

        # Step 7: Manual JSON formatting
        papers.append({
            "title": title,
            "summary": summary,
            "authors": authors[:3],
            "url": f"https://arxiv.org/abs/{paper_id}"
        })

    return papers

That's 50+ lines of code just to fetch papers!

The Solution With OpenClaw Agent

With OpenClaw Agent, I just write ONE command:

/frontierpilot find 10 research papers about machine learning from arXiv

That's it. No API URLs. No XML parsing. No manual data extraction.

How OpenClaw Agent Works Under the Hood

When I give this command, OpenClaw Agent automatically:

Step 1 - Understands: Reads my natural language command

Step 2 - Plans: Figures out I need papers from arXiv

Step 3 - Executes: Calls arXiv API with correct parameters

Step 4 - Parses: Extracts data from XML response

Step 5 - Formats: Converts to clean JSON

Step 6 - Returns: Gives me ready-to-use data

Agent Configuration I Created

I made a simple agent file frontierpilot.md that tells the agent what to do:

name: FrontierPilot
description: "Research assistant that finds research papers from arXiv"

tools:

arxiv_search
web_search

instructions: |
You are FrontierPilot, an AI research assistant.

When user asks for research papers:

Use arxiv_search tool to find papers
Extract title, authors, summary, url
Return as JSON array

Example:
User: "Find 5 papers about large language model"
You: Search arXiv, format as JSON, return results

Agent Integration in My Website

In my website's JavaScript, I call the agent like this:

// OpenClaw Gateway Configuration
const GATEWAY_URL = 'http://localhost:19001';

async function callOpenClawAgent(prompt) {
    const response = await fetch(`${GATEWAY_URL}/api/agent`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${GATEWAY_TOKEN}`
        },
        body: JSON.stringify({
            agent: "frontierpilot",
            prompt: prompt,
            session_id: "web_session_" + Date.now()
        })
    });
    return await response.json();
}

// When user clicks search button
searchBtn.addEventListener('click', async () => {
    const topic = topicInput.value;
    const numPapers = maxResults.value;

    const prompt = `Find ${numPapers} latest research papers about "${topic}" from arXiv. 
                    Return as JSON array with title, summary, authors (first 3), url, pdf_url, published date.`;

    const agentResponse = await callOpenClawAgent(prompt);
    const papers = JSON.parse(agentResponse.response);
    displayPapers(papers);
});

The Agent's Response Format

OpenClaw Agent returns clean, structured JSON:

[
{
"title": "Attention Is All You Need",
"summary": "The dominant sequence transduction models are based on complex RNNs and CNNs...",
"authors": ["Vaswani", "Shazeer", "Parmar"],
"url": "https://arxiv.org/abs/1706.03762",
"pdf_url": "https://arxiv.org/pdf/1706.03762.pdf",
"published": "2017-06-12"
},
{
"title": "BERT: Pre-training of Deep Bidirectional Transformers",
"summary": "We introduce a new language representation model called BERT...",
"authors": ["Devlin", "Chang", "Lee"],
"url": "https://arxiv.org/abs/1810.04805",
"pdf_url": "https://arxiv.org/pdf/1810.04805.pdf",
"published": "2018-10-11"
}
]

Why This is Powerful

Without OpenClaw: 50+ lines of code, must handle XML parsing, manual error handling, fixed functionality, hours of debugging

With OpenClaw: 1 command, agent handles everything, agent handles errors, natural language flexibility, works first time

Demo

Video Demo: Click here to watch

What I Learned

OpenClaw Agent Integration - Connecting web apps with AI agents using natural language

arXiv API - XML parsing and research paper data extraction

Multi-format Export - JSON, CSV, TXT, PDF generation from same data

Dark/Light Mode - CSS variables with localStorage persistence

Full Stack Development - Python Flask backend + Vanilla JS frontend

Key Challenges

XML Parsing - arXiv returns XML, not JSON. Agent handles this automatically.

CORS Issues - Flask-CORS solved cross-origin requests.

PDF Generation - html2pdf.js library made it easy.

Tech Stack

Frontend: HTML5, CSS3, JavaScript (Vanilla)

Backend: Python Flask

Agent: OpenClaw Agent Framework

API: arXiv API (Free, no key required)

PDF: html2pdf.js

How to Run Locally

# Clone the repository
git clone https://github.com/md-azad46/frontierpilot.git
cd frontierpilot

# Install dependencies
pip install flask flask-cors

# Start OpenClaw Gateway
cd ~/openclaw
node scripts/run-node.mjs --dev gateway

# Start Flask backend
cd frontierpilot
python backend.py

# Open index.html with Live Server

Requirements

Python 3.8+

OpenClaw installed

Modern web browser

Project Structure

frontierpilot/
├── backend.py # Flask API server
├── index.html # Home page (paper search)
├── communities.html # Communities page (Reddit, Discord, Conferences)
├── learning.html # Learning path page
├── researchers.html # Top researchers page
├── docs.html # Documentation page
├── styles.css # Global styles with Dark/Light mode
├── script.js # Main JavaScript with Agent integration
├── dashboard.js # Dashboard JavaScript
├── researchers.js # Researchers page JS
└── README.md # Documentation

Links