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

This is a submission for the OpenClaw Challenge.

What I Built

FrontierPilot - An AI-powered research assistant that fetches research papers from arXiv.

Users enter a research topic and instantly get:

→ Titles & summaries

→ Authors & publication dates

→ Direct PDF access

→ Export options (JSON, CSV, TXT, PDF)

Built with OpenClaw Agent - 1 command instead of 50+ lines of code.

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

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:

1. Use arxiv_search tool to find papers
2. Extract title, authors, summary, url
3. 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

Watch the full demo on YouTube:

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

Full Stack Development - Python Flask backend + Vanilla JS frontend

Project Screenshots with explain:

Homepage

FrontierPilot homepage showing research paper discovery interface. The interface displays search results for "large language model" with 10 papers found, 27 unique authors, 1.2 seconds search time, and top author "Renxi". Users can export results in JSON, CSV, or PDF format.

Project Structure

Project structure including backend.py, index.html, researchers.html, and JSON array format with title, authors, and arXiv URLs.

Communities to join

Communities page helps researchers find relevant subreddits, Discord servers, and academic conferences based on their research topic.

Top Researchers Feature

Discover the most active researchers in your field. The page shows author names, how many papers they've published on the topic, and direct links to their work.

PDF Paper Access

Every search result includes a PDF button. Clicking it opens the complete research paper directly in your browser - perfect for reading, downloading, or printing.

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

Conclusion

FrontierPilot shows how OpenClaw Agent can transform a complex 50+ line API integration into a simple natural language command. This project demonstrates that AI agents can make research tools more accessible to everyone, not just developers.

The OpenClaw Challenge proved that building AI-powered applications doesn't have to be complicated. With the right agent framework, anyone can build powerful tools that understand natural language and handle complex backend tasks automatically.

Future Plans

• 🔄 Real-time paper recommendations based on user history
• 📧 Email alerts for new papers in favorite topics
• 🤝 Collaborative features - share research collections
• 🔗 Integration with Zotero/Mendeley reference managers
• 🌍 Multi-language abstract translations

Acknowledgments

• arXiv.org for providing free API access to research papers
• OpenClaw Agent Framework for making AI integration seamless
• All researchers who make their work openly available on arXiv

Try It Yourself

Star on GitHub: github.com/md-azad46/frontierpilot

Built with ❤️ for the OpenClaw Challenge