diff --git a/papers/2502_06784v1.json b/papers/2502_06784v1.json
new file mode 100644
index 0000000..14e4b4a
--- /dev/null
+++ b/papers/2502_06784v1.json
@@ -0,0 +1,16 @@
+{
+  "title": "RelGNN: Composite Message Passing for Relational Deep Learning",
+  "authors": [
+    "Tianlang Chen",
+    "Charilaos Kanatsoulis",
+    "Jure Leskovec"
+  ],
+  "abstract": "Predictive tasks on relational databases are critical in real-world\napplications spanning e-commerce, healthcare, and social media. To address\nthese tasks effectively, Relational Deep Learning (RDL) encodes relational data\nas graphs, enabling Graph Neural Networks (GNNs) to exploit relational\nstructures for improved predictions. However, existing heterogeneous GNNs often\noverlook the intrinsic structural properties of relational databases, leading\nto modeling inefficiencies. Here we introduce RelGNN, a novel GNN framework\nspecifically designed to capture the unique characteristics of relational\ndatabases. At the core of our approach is the introduction of atomic routes,\nwhich are sequences of nodes forming high-order tripartite structures. Building\nupon these atomic routes, RelGNN designs new composite message passing\nmechanisms between heterogeneous nodes, allowing direct single-hop interactions\nbetween them. This approach avoids redundant aggregations and mitigates\ninformation entanglement, ultimately leading to more efficient and accurate\npredictive modeling. RelGNN is evaluated on 30 diverse real-world tasks from\nRelBench (Fey et al., 2024), and consistently achieves state-of-the-art\naccuracy with up to 25% improvement.",
+  "pdf_url": "http://arxiv.org/pdf/2502.06784v1",
+  "entry_id": "http://arxiv.org/abs/2502.06784v1",
+  "categories": [
+    "cs.LG",
+    "cs.AI",
+    "cs.DB"
+  ]
+}
\ No newline at end of file
diff --git a/papers/2502_06786v1.json b/papers/2502_06786v1.json
new file mode 100644
index 0000000..35f136e
--- /dev/null
+++ b/papers/2502_06786v1.json
@@ -0,0 +1,17 @@
+{
+  "title": "Matryoshka Quantization",
+  "authors": [
+    "Pranav Nair",
+    "Puranjay Datta",
+    "Jeff Dean",
+    "Prateek Jain",
+    "Aditya Kusupati"
+  ],
+  "abstract": "Quantizing model weights is critical for reducing the communication and\ninference costs of large models. However, quantizing models -- especially to\nlow precisions like int4 or int2 -- requires a trade-off in model quality;\nint2, in particular, is known to severely degrade model quality. Consequently,\npractitioners are often forced to maintain multiple models with different\nquantization levels or serve a single model that best satisfies the\nquality-latency trade-off. On the other hand, integer data types, such as int8,\ninherently possess a nested (Matryoshka) structure where smaller bit-width\nintegers, like int4 or int2, are nested within the most significant bits. This\npaper proposes Matryoshka Quantization (MatQuant), a novel multi-scale\nquantization technique that addresses the challenge of needing multiple\nquantized models. It allows training and maintaining just one model, which can\nthen be served at different precision levels. Furthermore, due to the\nco-training and co-distillation regularization provided by MatQuant, the int2\nprecision models extracted by MatQuant can be up to $10\\%$ more accurate than\nstandard int2 quantization (using techniques like QAT or OmniQuant). This\nrepresents significant progress in model quantization, demonstrated by the fact\nthat, with the same recipe, an int2 FFN-quantized Gemma-2 9B model is more\naccurate than an int8 FFN-quantized Gemma-2 2B model.",
+  "pdf_url": "http://arxiv.org/pdf/2502.06786v1",
+  "entry_id": "http://arxiv.org/abs/2502.06786v1",
+  "categories": [
+    "cs.LG",
+    "cs.AI"
+  ]
+}
\ No newline at end of file
diff --git a/src/main.py b/src/main.py
index 0351012..286a6bf 100644
--- a/src/main.py
+++ b/src/main.py
@@ -109,6 +109,15 @@ async def fetch_papers(days: int = 7, categories: Optional[List[str]] = None) ->
             logger.error(f"Error fetching papers: {e}")
             raise
 
+async def fetch_all_papers(categories: List[str], max_results: int = 1000):
+    """Fetch all papers from specified categories."""
+    async with ArxivClient() as client, AgentController() as agent:
+        for category in categories:
+            papers = await client.fetch_papers(category=category, max_results=max_results)
+            print(f"Found {len(papers)} papers in {category}")
+            for paper in papers:
+                await agent.analyze_paper(paper)
+
 async def fetch_single_paper(paper_id: str) -> None:
     """Fetch and analyze a single paper by ID."""
     print(f"\nFetching paper: {paper_id}")
@@ -231,6 +240,13 @@ async def main():
     fetch_parser.add_argument('--categories', nargs='+', default=['cs.AI'],
                             help='arXiv categories to fetch')
     
+    # Fetch all papers command
+    fetch_all_parser = subparsers.add_parser('fetch-all', help='Fetch all papers from categories')
+    fetch_all_parser.add_argument('--categories', nargs='+', default=['cs.AI'],
+                               help='arXiv categories to fetch')
+    fetch_all_parser.add_argument('--max-results', type=int, default=1000,
+                               help='Maximum number of papers to fetch per category')
+    
     # Fetch single paper command
     fetch_one_parser = subparsers.add_parser('fetch-paper', help='Fetch and analyze a single paper')
     fetch_one_parser.add_argument('paper_id', help='arXiv paper ID (e.g., 2502.06788v1)')
@@ -250,6 +266,8 @@ async def main():
     
     if args.command == 'fetch':
         await fetch_papers(days=args.days, categories=args.categories)
+    elif args.command == 'fetch-all':
+        await fetch_all_papers(args.categories, args.max_results)
     elif args.command == 'fetch-paper':
         await fetch_single_paper(args.paper_id)
     elif args.command == 'search':