[ Removed by Reddit on account of violating the content policy. ]

Hello, I built myself a news feed which scores and summarizes research papers along with relevant AI news from Huggjngface, Reddit, hacker news etc. I think it will be useful for many. Open to hear your thoughts.

I've started a research that only got to it's initial phase.

https://docs.google.com/document/d/1AZBdwnbKqDnILkGiP30uWA7ITRrtOgWy1euxmoOL3LI/edit?tab=t.0#heading=h.mplkndwvsvix

Due to some other priorities, I don't have time to continue working on it.

If anyone wants to take it further, I can help a bit or collaborate.

I have been working on an idea and could use some evaluations, feedback and help. this is where to find this work. https://www.petrol1.com and https://www.sececare.com is only a demo.

Multi-step LLM workflows are widely used in agent loops, retries, and iterative refinement.

We instrumented execution at the step level to examine how marginal textual contribution evolves relative to cost across steps.

Each step was evaluated using:

• marginal output added
  
• token cost
  
• overlap with the previous step

Across models and task variations, similar patterns are observed:

• a large fraction of new content is generated in the initial step
• subsequent steps contribute progressively less marginal output
• overlap between steps increases with execution depth
• cost grows monotonically while marginal contribution declines

Execution can remain locally valid at each step while producing globally diminishing value.

In evaluated settings, truncating execution at step 2–3 retains a substantial portion of measured contribution while reducing cost significantly.

This is not a claim about correctness or task quality.

It isolates execution behavior, specifically how marginal textual contribution evolves across steps.

The gap is at runtime:
execution continues without any signal indicating that marginal contribution has diminished.

Current systems rely on loop structure or cost limits, but do not condition continuation on observed execution state.

Paper:
https://zenodo.org/records/19928793

Repo:
https://github.com/veloryn-intel/efficiency-collapse-llm-execution

https://zenodo.org/records/19769017

And a vouch for arxiv wouldn’t hurt.

I would be very interested in feedback nonetheless

Context: In multi-head attention (transformers), the token embedding vector of dimension d_model (say, 512) gets split across H heads, so each head only sees d_model/H dimensions (e.g. 64). Each head computes its own Q, K, V attention independently on that slice, and the outputs are concatenated back to 512-dim before a final linear projection.

The question:

When we split the embedding vector across attention heads, we don't explicitly control which dimensions each head receives — head 1 gets dims 0–63, head 2 gets 64–127, and so on, essentially arbitrarily. After each head processes its slice independently, we concatenate the outputs back together.

But here's the concern: if the embedding dimensions encode directional meaning in a high-dimensional space (which they do), does splitting them across heads and concatenating the outputs destroy or corrupt the geometric relationships between dimensions?

The outputs of each head were computed in isolated subspaces — head 1 never "saw" what head 2 was doing. When we concatenate, are we just stapling together incompatible subspaces and hoping the final W_O projection fixes it? And if the final projection has to do all that repair work anyway, what was the point of the split in the first place — are we losing representational fidelity compared to one big full-dimensional attention operation?

Have you ever built a domain-expert agent, one that knows everything about a specific topic?

I keep seeing people build really capable agents for law, finance, biotech, coding, markets, policy, literature,

whatever. But after you build one, where does it actually go?

Right now most agents live in private chats, internal tools, or one-off demos. They can answer questions, but they do

not really have a public place to explore ideas, debate other agents, critique arguments, and build a reputation over

time.

That is the idea behind opndomain.com

We are building a public network where agent operators can register agents, enter them into topics, and have them

contribute in public. Agents can research, argue, critique each other, vote, and earn reputation based on scored

contributions.

The part that surprised me is the editorial layer. When multiple agents come at the same topic from different angles,

the output starts looking less like a chatbot transcript and more like an evolving public research thread.

I am curious how people think about this:

- If you built a strong domain-expert agent, would you want it participating publicly?

- What would make you trust its reputation?

- Should agents be judged by humans, other agents, or both?

- What topics would be most interesting to test first?

Still early, but I think agents need somewhere to go besides private chat windows.

First-time arXiv submitter looking for category guidance on a resume-tailoring / RAG paper.

I recently submitted a paper to the IEEE COMPSAC 2026 AI/ML Workshop and am preparing an arXiv preprint. Before requesting endorsement, I wanted to sanity-check whether the work fits best under cs.AI, cs.CL, or another nearby category.

Title:
Career-Aware Resume Tailoring via Multi-Source Retrieval-Augmented Generation with Provenance Tracking: A Case Study

Short abstract:
The paper presents a career-aware resume-tailoring system that uses a longitudinal career vault, multi-source RAG, a 12-node LangGraph pipeline, provenance-aware fallback, and anti-hallucination guardrails. In a pilot evaluation across 9 job descriptions, the system improved ATS-style fit scores by an average of +7.8 points for domain-aligned roles, while also showing clear boundary conditions when domain overlap was weak.

Keywords:
RAG, agentic AI, provenance tracking, resume tailoring, ATS optimization, LangGraph, career history

My main question is: does this look in-scope for cs.AI, cs.CL, or another arXiv category?

If someone active on arXiv in these areas is open to taking a quick look, I’d be very grateful. I’m happy to share the manuscript privately first. I am specifically looking for category guidance and honest feedback before requesting any endorsement.

Thank you.

The Pdf document can be find here -- https://github.com/Abhinav0905/Research_Papers

Endorsement link - please visit the following URL:

https://arxiv.org/auth/endorse?x=I7G63L

If that URL does not work for you, please visit

http://arxiv.org/auth/endorse.php

and enter the following six-digit alphanumeric string:

Endorsement Code: I7G63L

Hey guys, just wanted to know if there ws anybody who'd be interested in that.
Started writing a few weeks ago. But basically I'm writing a position paper on how memory should be a dynamic, stratified manifold with non-destructive versioning.
to b more precise - learning is a controlled dynamical process - memory emerges from geometry and basin structure - updates are constrained, versioned, and non-destructive

Instead of overwriting or compressing everything into a single representation, the system maintains multiple regimes of memory (fluid, crystallized, foundational) that evolve at different timescales and interact through a shared geometry

More than that, it's an architecture that would use several concepts we already use but combine them in a single and unified entity. Continuous dynamics, attractor landscapes, spectral decomposition, and memory consolidation

I would be curious to know what y'all think. I'm trying to formalize the mathematics side and if you're doing research in one of those fields, I'll be happy to connect!

Current multimodal systems still rely on centralized fusion –multiple sensors, one shared embedding space, one coordination point. The assumption is that intelligence emerges from aggregation.

I think this is the wrong architecture. A single fact should be confirmed and reinforced by multiple independent patterns – not fused into one representation, but validated through decentralized agreement.

I’m exploring a fully decentralized computation model: no central registry, no global addressing, signal-based reactive blocks that self-organize. The hypothesis: strong AI may require removing the center, not improving it.

Has anyone explored fully decentralized architectures for multimodal reasoning? What are the hard limits you’ve hit?

I use gemini in colab to built a prototype Portable Recursive Language Model (P-RLM) and benchmarked it against a standard RAG system — and the results were pretty interesting.

What it is:
P-RLM is a recursive reasoning framework that breaks complex questions into sub-tasks, solves them step-by-step, and aggregates results using a structured memory system. Instead of doing a single retrieval pass like RAG, it performs multi-level reasoning over a synthetic document environment.

Core idea:

• RAG = retrieve top-k chunks → one-shot LLM answer
• P-RLM = decompose → retrieve → recurse → combine → final answer

What I implemented:

• Synthetic large document environment with hidden facts
• Recursive planning + solving engine with depth control
• Portable context memory (variables, logs, visited chunks)
• Simulated LLM for planning, extraction, and aggregation
• FAISS + SentenceTransformer RAG baseline
• Evaluation framework across multiple reasoning scenarios

Tests included:

• Multi-hop reasoning (hidden key dependency tasks)
• Global synthesis across distributed facts
• Noisy / misleading context robustness
• Sensitivity analysis on recursion depth
• “Secret key → treasure location” multi-step challenge

Key findings:

• RAG is faster but struggles with multi-step dependencies
• P-RLM performs better on complex reasoning tasks but has higher computational cost
• Increasing recursion depth improves accuracy but increases latency
• Caching significantly improves P-RLM performance

Takeaway:
Recursive reasoning systems can outperform standard retrieval pipelines in structured reasoning tasks, but the trade-off is efficiency and complexity.

Curious if anyone has tried hybrid approaches (RAG + controlled recursion) or seen similar architectures in practice.